diff --git a/Makefile.in b/Makefile.in
index 2ea4562..351a0c3 100644
--- a/Makefile.in
+++ b/Makefile.in
@@ -39,6 +39,7 @@
 	dlls/psapi \
 	dlls/rasapi32 \
 	dlls/shell32 \
+	dlls/tapi32 \
 	dlls/ver \
 	dlls/version \
 	dlls/winaspi \
@@ -112,6 +113,7 @@
 	dlls/psapi/psapi.o \
 	dlls/rasapi32/rasapi32.o \
 	dlls/shell32/shell32.o \
+	dlls/tapi32/tapi32.o \
 	dlls/ver/ver.o \
 	dlls/version/version.o \
 	dlls/winaspi/winaspi.o \
diff --git a/configure b/configure
index d21293d..a83b473 100755
--- a/configure
+++ b/configure
@@ -4607,6 +4607,7 @@
 dlls/psapi/Makefile
 dlls/rasapi32/Makefile
 dlls/shell32/Makefile
+dlls/tapi32/Makefile
 dlls/ver/Makefile
 dlls/version/Makefile
 dlls/winaspi/Makefile
@@ -4769,6 +4770,7 @@
 dlls/psapi/Makefile
 dlls/rasapi32/Makefile
 dlls/shell32/Makefile
+dlls/tapi32/Makefile
 dlls/ver/Makefile
 dlls/version/Makefile
 dlls/winaspi/Makefile
diff --git a/configure.in b/configure.in
index 242d483..e2fa923 100644
--- a/configure.in
+++ b/configure.in
@@ -632,6 +632,7 @@
 dlls/psapi/Makefile
 dlls/rasapi32/Makefile
 dlls/shell32/Makefile
+dlls/tapi32/Makefile
 dlls/ver/Makefile
 dlls/version/Makefile
 dlls/winaspi/Makefile
diff --git a/dlls/Makefile.in b/dlls/Makefile.in
index dff6343..76cc186 100644
--- a/dlls/Makefile.in
+++ b/dlls/Makefile.in
@@ -9,6 +9,7 @@
 	ntdll \
 	psapi \
 	shell32 \
+	tapi32 \
 	ver \
 	version \
 	winaspi \
diff --git a/dlls/tapi32/.cvsignore b/dlls/tapi32/.cvsignore
new file mode 100644
index 0000000..f3c7a7c
--- /dev/null
+++ b/dlls/tapi32/.cvsignore
@@ -0,0 +1 @@
+Makefile
diff --git a/dlls/tapi32/Makefile.in b/dlls/tapi32/Makefile.in
new file mode 100644
index 0000000..5c2c793
--- /dev/null
+++ b/dlls/tapi32/Makefile.in
@@ -0,0 +1,18 @@
+DEFS      = @DLLFLAGS@ -D__WINE__
+TOPSRCDIR = @top_srcdir@
+TOPOBJDIR = ../..
+SRCDIR    = @srcdir@
+VPATH     = @srcdir@
+MODULE    = tapi32
+
+C_SRCS = \
+	assisted.c \
+	line.c \
+	phone.c
+
+all: $(MODULE).o
+
+@MAKE_RULES@
+
+### Dependencies:
+
diff --git a/dlls/tapi32/assisted.c b/dlls/tapi32/assisted.c
new file mode 100644
index 0000000..429e4a3
--- /dev/null
+++ b/dlls/tapi32/assisted.c
@@ -0,0 +1,29 @@
+/*
+ * TAPI32 Assisted Telephony
+ *
+ * Copyright 1999  Andreas Mohr
+ */
+
+#include "winbase.h"
+#include "wintypes.h"
+#include "tapi.h"
+#include "debug.h"
+
+DWORD WINAPI tapiGetLocationInfo(LPSTR lpszCountryCode, LPSTR lpszCityCode)
+{
+    char temp[30];
+    
+    FIXME(tapi, "(%s, %s): file sections ???\n", lpszCountryCode, lpszCityCode);
+    if (!(GetPrivateProfileStringA("Locations", "CurrentLocation", "", temp, 30, "telephon.ini")))
+        return TAPIERR_REQUESTFAILED;
+    if (!(GetPrivateProfileStringA("Locations", "FIXME_ENTRY", "", lpszCityCode, 8, "telephon.ini"))) 
+        return TAPIERR_REQUESTFAILED;
+    return 0;
+}
+
+DWORD WINAPI tapiRequestMakeCall(LPCSTR lpszDestAddress, LPCSTR lpszAppName,
+                                 LPCSTR lpszCalledParty, LPCSTR lpszComment)
+{
+    FIXME(tapi, "(%s, %s, %s, %s): stub.\n", lpszDestAddress, lpszAppName, lpszCalledParty, lpszComment);
+    return 0;
+}
diff --git a/dlls/tapi32/line.c b/dlls/tapi32/line.c
new file mode 100644
index 0000000..8219052
--- /dev/null
+++ b/dlls/tapi32/line.c
@@ -0,0 +1,526 @@
+/*
+ * TAPI32 line services
+ *
+ * Copyright 1999  Andreas Mohr
+ */
+
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include "winbase.h"
+#include "wintypes.h"
+#include "tapi.h"
+#include "debug.h"
+
+DWORD WINAPI lineAccept(HCALL hCall, LPCSTR lpsUserUserInfo, DWORD dwSize)
+{
+    FIXME(tapi, "(%04x, %s, %ld): stub.\n", hCall, lpsUserUserInfo, dwSize);
+    return 1;
+}
+
+DWORD WINAPI lineAddProvider(LPCSTR lpszProviderName, HWND hwndOwner, LPDWORD lpdwPermanentProviderID)
+{
+    FIXME(tapi, "(%s, %04x, %p): stub.\n", lpszProviderName, hwndOwner, lpdwPermanentProviderID);
+    return 1;
+}	
+
+DWORD WINAPI lineAddToConference(HCALL hConfCall, HCALL hConsultCall)
+{
+    FIXME(tapi, "(%04x, %04x): stub.\n", hConfCall, hConsultCall);
+    return 1;
+}
+
+DWORD WINAPI lineAnswer(HCALL hCall, LPCSTR lpsUserUserInfo, DWORD dwSize)
+{
+    FIXME(tapi, "(%04x, %s, %ld): stub.\n", hCall, lpsUserUserInfo, dwSize);
+    return 1;
+}	
+
+DWORD WINAPI lineBlindTransfer(HCALL hCall, LPCSTR lpszDestAddress, DWORD dwCountryCode)
+{
+    FIXME(tapi, "(%04x, %s, %08lx): stub.\n", hCall, lpszDestAddress, dwCountryCode);
+    return 1;
+}	
+
+DWORD WINAPI lineClose(HLINE hLine)
+{
+    FIXME(tapi, "(%04x): stub.\n", hLine);
+    return 0;
+}	
+
+DWORD WINAPI lineCompleteCall(HCALL hCall, LPDWORD lpdwCompletionID, DWORD dwCompletionMode, DWORD dwMessageID)
+{
+    FIXME(tapi, "(%04x, %p, %08lx, %08lx): stub.\n", hCall, lpdwCompletionID, dwCompletionMode, dwMessageID);
+    return 1;
+}	
+
+DWORD WINAPI lineCompleteTransfer(HCALL hCall, HCALL hConsultCall, LPHCALL lphConfCall, DWORD dwTransferMode)
+{
+    FIXME(tapi, "(%04x, %04x, %p, %08lx): stub.\n", hCall, hConsultCall, lphConfCall, dwTransferMode);
+    return 1;
+}
+
+DWORD WINAPI lineConfigDialog(DWORD dwDeviceID, HWND hwndOwner, LPCSTR lpszDeviceClass)
+{
+    FIXME(tapi, "(%08lx, %04x, %s): stub.\n", dwDeviceID, hwndOwner, lpszDeviceClass);
+    return 0;
+}	
+
+DWORD WINAPI lineConfigDialogEdit(DWORD dwDeviceID, HWND hwndOwner, LPCSTR lpszDeviceClass, LPVOID const lpDeviceConfigIn, DWORD dwSize, LPVARSTRING lpDeviceConfigOut)
+{
+    FIXME(tapi, "stub.\n");
+    return 0;
+}	
+
+DWORD WINAPI lineConfigProvider(HWND hwndOwner, DWORD dwPermanentProviderID)
+{
+    FIXME(tapi, "(%04x, %08lx): stub.\n", hwndOwner, dwPermanentProviderID);
+    return 0;
+}
+
+DWORD WINAPI lineDeallocateCall(HCALL hCall)
+{
+    FIXME(tapi, "(%04x): stub.\n", hCall);
+    return 0;
+}
+
+DWORD WINAPI lineDevSpecific(HLINE hLine, DWORD dwAddressId, HCALL hCall, LPVOID lpParams, DWORD dwSize)
+{
+    FIXME(tapi, "(%04x, %08lx, %04x, %p, %ld): stub.\n", hLine, dwAddressId, hCall, lpParams, dwSize);
+    return 1;
+}	
+
+DWORD WINAPI lineDevSpecificFeature(HLINE hLine, DWORD dwFeature, LPVOID lpParams, DWORD dwSize)
+{
+    FIXME(tapi, "(%04x, %08lx, %p, %ld): stub.\n", hLine, dwFeature, lpParams, dwSize);
+    return 1;
+}
+
+DWORD WINAPI lineDial(HCALL hCall, LPCSTR lpszDestAddress, DWORD dwCountryCode)
+{
+    FIXME(tapi, "(%04x, %s, %08lx): stub.\n", hCall, lpszDestAddress, dwCountryCode);
+    return 1;
+}
+    
+DWORD WINAPI lineDrop(HCALL hCall, LPCSTR lpsUserUserInfo, DWORD dwSize)
+{
+    FIXME(tapi, "(%04x, %s, %08lx): stub.\n", hCall, lpsUserUserInfo, dwSize);
+    return 1;
+}
+
+DWORD WINAPI lineForward(HLINE hLine, DWORD bAllAddress, DWORD dwAdressID, LPLINEFORWARDLIST lpForwardList, DWORD dwNumRingsNoAnswer, LPHCALL lphConsultCall, LPLINECALLPARAMS lpCallParams)
+{
+    FIXME(tapi, "stub.\n");
+    return 1;
+}	
+	
+DWORD WINAPI lineGatherDigits(HCALL hCall, DWORD dwDigitModes, LPSTR lpsDigits, DWORD dwNumDigits, LPCSTR lpszTerminationDigits, DWORD dwFirstDigitTimeout, DWORD dwInterDigitTimeout)
+{
+    FIXME(tapi, "stub.\n");
+    return 0;
+}
+
+DWORD WINAPI lineGenerateDigits(HCALL hCall, DWORD dwDigitModes, LPCSTR lpszDigits, DWORD dwDuration)
+{
+    FIXME(tapi, "(%04x, %08lx, %s, %ld): stub.\n", hCall, dwDigitModes, lpszDigits, dwDuration);
+    return 0;
+}
+
+DWORD WINAPI lineGenerateTone(HCALL hCall, DWORD dwToneMode, DWORD dwDuration, DWORD dwNumTones, LPLINEGENERATETONE lpTones)
+{
+    FIXME(tapi, "(%04x, %08lx, %ld, %ld, %p): stub.\n", hCall, dwToneMode, dwDuration, dwNumTones, lpTones);
+    return 0;
+}	
+
+DWORD WINAPI lineGetAddressCaps(HLINEAPP hLineApp, DWORD dwDeviceID, DWORD dwAddressID, DWORD dwAPIVersion, DWORD dwExtVersion, LPLINEADDRESSCAPS lpAddressCaps)
+{
+    FIXME(tapi, "(%04x, %08lx, %08lx, %08lx, %08lx, %p): stub.\n", hLineApp, dwDeviceID, dwAddressID, dwAPIVersion, dwExtVersion, lpAddressCaps);
+    return 0;
+}
+
+DWORD WINAPI lineGetAddressID(HLINE hLine, LPDWORD lpdwAddressID, DWORD dwAddressMode, LPCSTR lpsAddress, DWORD dwSize)
+{
+    FIXME(tapi, "%04x, %p, %08lx, %s, %ld): stub.\n", hLine, lpdwAddressID, dwAddressMode, lpsAddress, dwSize);
+    return 0;
+}
+
+DWORD WINAPI lineGetAddressStatus(HLINE hLine, DWORD dwAddressID, LPLINEADDRESSSTATUS lpAddressStatus)
+{
+    FIXME(tapi, "(%04x, %08lx, %p): stub.\n", hLine, dwAddressID, lpAddressStatus);
+    return 0;
+}	
+
+DWORD WINAPI lineGetAppPriority(LPCSTR lpszAppFilename, DWORD dwMediaMode, LPLINEEXTENSIONID const lpExtensionID, DWORD dwRequestMode, LPVARSTRING lpExtensionName, LPDWORD lpdwPriority)
+{
+    FIXME(tapi, "(%s, %08lx, %p, %08lx, %p, %p): stub.\n", lpszAppFilename, dwMediaMode, lpExtensionID, dwRequestMode, lpExtensionName, lpdwPriority);
+    return 0;
+}	
+
+DWORD WINAPI lineGetCallInfo(HCALL hCall, LPLINECALLINFO lpCallInfo)
+{
+    FIXME(tapi, "(%04x, %p): stub.\n", hCall, lpCallInfo);
+    return 0;
+}
+
+DWORD WINAPI lineGetCallStatus(HCALL hCall, LPLINECALLSTATUS lpCallStatus)
+{
+    FIXME(tapi, "(%04x, %p): stub.\n", hCall, lpCallStatus);
+    return 0;
+}
+
+DWORD WINAPI lineGetConfRelatedCalls(HCALL hCall, LPLINECALLLIST lpCallList)
+{
+    FIXME(tapi, "(%04x, %p): stub.\n", hCall, lpCallList);
+    return 0;
+}	
+
+DWORD WINAPI lineGetCountry(DWORD dwCountryID, DWORD dwAPIVersion, LPLINECOUNTRYLIST lpLineCountryList)
+{
+    FIXME(tapi, "(%08lx, %08lx, %p): stub.\n", dwCountryID, dwAPIVersion, lpLineCountryList);
+    return 0;
+}
+
+DWORD WINAPI lineGetDevCaps(HLINEAPP hLineApp, DWORD dwDeviceID, DWORD dwAPIVersion, DWORD dwExtVersion, LPLINEDEVCAPS lpLineDevCaps)
+{
+    FIXME(tapi, "(%04x, %08lx, %08lx, %08lx, %p): stub.\n", hLineApp, dwDeviceID, dwAPIVersion, dwExtVersion, lpLineDevCaps);
+    return 0;
+}	
+
+DWORD WINAPI lineGetDevConfig(DWORD dwDeviceID, LPVARSTRING lpDeviceConfig, LPCSTR lpszDeviceClass)
+{
+    FIXME(tapi, "(%08lx, %p, %s): stub.\n", dwDeviceID, lpDeviceConfig, lpszDeviceClass);
+    return 0;
+}
+
+DWORD WINAPI lineGetID(HLINE hLine, DWORD dwAddressID, HCALL hCall, DWORD dwSelect, LPVARSTRING lpDeviceID, LPCSTR lpszDeviceClass)
+{
+    FIXME(tapi, "(%04x, %08lx, %04x, %08lx, %p, %s): stub.\n", hLine, dwAddressID, hCall, dwSelect, lpDeviceID, lpszDeviceClass);
+    return 0;
+}
+
+DWORD WINAPI lineGetIcon(DWORD dwDeviceID, LPCSTR lpszDeviceClass, HICON *lphIcon)
+{
+    FIXME(tapi, "(%08lx, %s, %p): stub.\n", dwDeviceID, lpszDeviceClass, lphIcon);
+    return 0;
+}	
+
+DWORD WINAPI lineGetLineDevStatus(HLINE hLine, LPLINEDEVSTATUS lpLineDevStatus)
+{
+    FIXME(tapi, "(%04x, %p): stub.\n", hLine, lpLineDevStatus);
+    return 0;
+}	
+
+DWORD WINAPI lineGetNewCalls(HLINE hLine, DWORD dwAddressID, DWORD dwSelect, LPLINECALLLIST lpCallList)
+{
+    FIXME(tapi, "(%04x, %08lx, %08lx, %p): stub.\n", hLine, dwAddressID, dwSelect, lpCallList);
+    return 0;
+}
+
+
+DWORD WINAPI lineGetNumRings(HLINE hLine, DWORD dwAddressID, LPDWORD lpdwNumRings)
+{
+    FIXME(tapi, "(%04x, %08lx, %p): stub.\n", hLine, dwAddressID, lpdwNumRings);
+    return 0;
+}
+
+DWORD WINAPI lineGetProviderList(DWORD dwAPIVersion, LPLINEPROVIDERLIST lpProviderList)
+{
+    FIXME(tapi, "(%08lx, %p): stub.\n", dwAPIVersion, lpProviderList);
+    return 0;
+}	
+
+DWORD WINAPI lineGetRequest(HLINEAPP hLineApp, DWORD dwRequestMode, LPVOID lpRequestBuffer)
+{
+    FIXME(tapi, "%04x, %08lx, %p): stub.\n", hLineApp, dwRequestMode, lpRequestBuffer);
+    return 0;
+}	
+
+DWORD WINAPI lineGetStatusMessages(HLINE hLine, LPDWORD lpdwLineStatus, LPDWORD lpdwAddressStates)
+{
+    FIXME(tapi, "(%04x, %p, %p): stub.\n", hLine, lpdwLineStatus, lpdwAddressStates);
+    return 0;
+}	
+
+DWORD WINAPI lineGetTranslateCaps(HLINEAPP hLineApp, DWORD dwAPIVersion, LPLINETRANSLATECAPS lpTranslateCaps)
+{
+    FIXME(tapi, "(%04x, %08lx, %p): stub.\n", hLineApp, dwAPIVersion, lpTranslateCaps);
+    return 0;
+}
+
+DWORD WINAPI lineHandoff(HCALL hCall, LPCSTR lpszFileName, DWORD dwMediaMode)
+{
+    FIXME(tapi, "(%04x, %s, %08lx): stub.\n", hCall, lpszFileName, dwMediaMode);
+    return 0;
+}	
+
+DWORD WINAPI lineHold(HCALL hCall)
+{
+    FIXME(tapi, "(%04x): stub.\n", hCall);
+    return 1;
+}	
+
+DWORD WINAPI lineInitialize(
+  LPHLINEAPP lphLineApp,
+  HINSTANCE hInstance,
+  LINECALLBACK lpfnCallback,
+  LPCSTR lpszAppName,
+  LPDWORD lpdwNumDevs)
+{
+    FIXME(comm, "stub.\n");
+    return 0;
+}
+
+DWORD WINAPI lineMakeCall(HLINE hLine, LPHCALL lphCall, LPCSTR lpszDestAddress, DWORD dwCountryCode, LPLINECALLPARAMS lpCallParams)
+{
+    FIXME(tapi, "(%04x, %p, %s, %08lx, %p): stub.\n", hLine, lphCall, lpszDestAddress, dwCountryCode, lpCallParams);
+    return 1;
+}
+
+DWORD WINAPI lineMonitorDigits(HCALL hCall, DWORD dwDigitModes)
+{
+    FIXME(tapi, "(%04x, %08lx): stub.\n", hCall, dwDigitModes);
+    return 0;
+}
+
+DWORD WINAPI lineMonitorMedia(HCALL hCall, DWORD dwMediaModes)
+{
+    FIXME(tapi, "(%04x, %08lx): stub.\n", hCall, dwMediaModes);
+    return 0;
+}	
+
+DWORD WINAPI lineMonitorTones(HCALL hCall, LPLINEMONITORTONE lpToneList, DWORD dwNumEntries)
+{
+    FIXME(tapi, "(%04x, %p, %08lx): stub.\n", hCall, lpToneList, dwNumEntries);
+    return 0;
+}	
+
+DWORD WINAPI lineNegotiateAPIVersion(
+  HLINEAPP hLineApp,
+  DWORD dwDeviceID,
+  DWORD dwAPILowVersion,
+  DWORD dwAPIHighVersion,
+  LPDWORD lpdwAPIVersion,
+  LPLINEEXTENSIONID lpExtensionID
+)
+{
+    FIXME(comm, "stub.\n");
+    *lpdwAPIVersion = dwAPIHighVersion;
+    return 0;
+}
+
+DWORD WINAPI lineNegotiateExtVersion(HLINEAPP hLineApp, DWORD dwDeviceID, DWORD dwAPIVersion, DWORD dwExtLowVersion, DWORD dwExtHighVersion, LPDWORD lpdwExtVersion)
+{
+    FIXME(tapi, "stub.\n");
+    return 0;
+}
+
+DWORD WINAPI lineOpen(HLINEAPP hLineApp, DWORD dwDeviceID, LPHLINE lphLine, DWORD dwAPIVersion, DWORD dwExtVersion, DWORD dwCallbackInstance, DWORD dwPrivileges, DWORD dwMediaModes, LPLINECALLPARAMS lpCallParams)
+{
+    FIXME(tapi, "stub.\n");
+    return 0;
+}
+
+DWORD WINAPI linePark(HCALL hCall, DWORD dwParkMode, LPCSTR lpszDirAddress, LPVARSTRING lpNonDirAddress)
+{
+    FIXME(tapi, "(%04x, %08lx, %s, %p): stub.\n", hCall, dwParkMode, lpszDirAddress, lpNonDirAddress);
+    return 1;
+}	
+
+DWORD WINAPI linePickup(HLINE hLine, DWORD dwAddressID, LPHCALL lphCall, LPCSTR lpszDestAddress, LPCSTR lpszGroupID)
+{
+    FIXME(tapi, "(%04x, %08lx, %p, %s, %s): stub.\n", hLine, dwAddressID, lphCall, lpszDestAddress, lpszGroupID);
+    return 1;
+}	
+
+DWORD WINAPI linePrepareAddToConference(HCALL hConfCall, LPHCALL lphConsultCall, LPLINECALLPARAMS lpCallParams)
+{
+    FIXME(tapi, "(%04x, %p, %p): stub.\n", hConfCall, lphConsultCall, lpCallParams);
+    return 1;
+}	
+
+/*************************************************************************
+ * lineRedirect [TAPI32.53]
+ * 
+ */
+DWORD WINAPI lineRedirect(
+  HCALL hCall,
+  LPCSTR lpszDestAddress,
+  DWORD  dwCountryCode) {
+
+  FIXME(comm, ": stub.\n");
+  return 1;
+}
+
+DWORD WINAPI lineRegisterRequestRecipient(HLINEAPP hLineApp, DWORD dwRegistrationInstance, DWORD dwRequestMode, DWORD dwEnable)
+{
+    FIXME(tapi, "(%04x, %08lx, %08lx, %08lx): stub.\n", hLineApp, dwRegistrationInstance, dwRequestMode, dwEnable);
+    return 1;
+}
+
+DWORD WINAPI lineReleaseUserUserInfo(HCALL hCall)
+{
+    FIXME(tapi, "(%04x): stub.\n", hCall);
+    return 1;
+}	
+
+DWORD WINAPI lineRemoveFromConference(HCALL hCall)
+{
+    FIXME(tapi, "(%04x): stub.\n", hCall);
+    return 1;
+}
+
+DWORD WINAPI lineRemoveProvider(DWORD dwPermanentProviderID, HWND hwndOwner)
+{
+    FIXME(tapi, "(%08lx, %04x): stub.\n", dwPermanentProviderID, hwndOwner);
+    return 1;
+}	
+
+DWORD WINAPI lineSecureCall(HCALL hCall)
+{
+    FIXME(tapi, "(%04x): stub.\n", hCall);
+    return 1;
+}
+
+DWORD WINAPI lineSendUserUserInfo(HCALL hCall, LPCSTR lpsUserUserInfo, DWORD dwSize)
+{
+    FIXME(tapi, "(%04x, %s, %08lx): stub.\n", hCall, lpsUserUserInfo, dwSize);
+    return 1;
+}
+
+DWORD WINAPI lineSetAppPriority(LPCSTR lpszAppFilename, DWORD dwMediaMode, LPLINEEXTENSIONID const lpExtensionID, DWORD dwRequestMode, LPCSTR lpszExtensionName, DWORD dwPriority)
+{
+    FIXME(tapi, "(%s, %08lx, %p, %08lx, %s, %08lx): stub.\n", lpszAppFilename, dwMediaMode, lpExtensionID, dwRequestMode, lpszExtensionName, dwPriority);
+    return 0;
+}
+
+DWORD WINAPI lineSetAppSpecific(HCALL hCall, DWORD dwAppSpecific)
+{
+    FIXME(tapi, "(%04x, %08lx): stub.\n", hCall, dwAppSpecific);
+    return 0;
+}
+
+DWORD WINAPI lineSetCallParams(HCALL hCall, DWORD dwBearerMode, DWORD dwMinRate, DWORD dwMaxRate, LPLINEDIALPARAMS lpDialParams)
+{
+    FIXME(tapi, "(%04x, %08lx, %08lx, %08lx, %p): stub.\n", hCall, dwBearerMode, dwMinRate, dwMaxRate, lpDialParams);
+    return 1;
+}
+
+DWORD WINAPI lineSetCallPrivilege(HCALL hCall, DWORD dwCallPrivilege)
+{
+    FIXME(tapi, "(%04x, %08lx): stub.\n", hCall, dwCallPrivilege);
+    return 0;
+}	
+		
+DWORD WINAPI lineSetCurrentLocation(HLINEAPP hLineApp, DWORD dwLocation)
+{
+    FIXME(tapi, "(%04x, %08lx): stub.\n", hLineApp, dwLocation);
+    return 0;
+}
+
+DWORD WINAPI lineSetDevConfig(DWORD dwDeviceID, LPVOID lpDeviceConfig, DWORD dwSize, LPCSTR lpszDeviceClass)
+{
+    FIXME(tapi, "(%0lx, %p, %08lx, %s): stub.\n", dwDeviceID, lpDeviceConfig, dwSize, lpszDeviceClass);
+    return 0;
+}
+
+DWORD 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)
+{
+    FIXME(tapi, ": stub.\n");
+    return 0;
+}
+
+DWORD WINAPI lineSetMediaMode(HCALL hCall, DWORD dwMediaModes)
+{
+    FIXME(tapi, "(%04x, %08lx): stub.\n", hCall, dwMediaModes);
+    return 0;
+}	
+
+DWORD WINAPI lineSetNumRings(HLINE hLine, DWORD dwAddressID, DWORD dwNumRings)
+{
+    FIXME(tapi, "(%04x, %08lx, %08lx): stub.\n", hLine, dwAddressID, dwNumRings);
+    return 0;
+}	
+		
+DWORD WINAPI lineSetStatusMessages(HLINE hLine, DWORD dwLineStates, DWORD dwAddressStates)
+{
+    FIXME(tapi, "(%04x, %08lx, %08lx): stub.\n", hLine, dwLineStates, dwAddressStates);
+    return 0;
+}	
+		
+DWORD WINAPI lineSetTerminal(HLINE hLine, DWORD dwAddressID, HCALL hCall, DWORD dwSelect, DWORD dwTerminalModes, DWORD dwTerminalID, DWORD bEnable)
+{
+    FIXME(tapi, "(%04x, %08lx, %04x, %08lx, %08lx, %08lx, %08lx): stub.\n", hLine, dwAddressID, hCall, dwSelect, dwTerminalModes, dwTerminalID, bEnable);
+    return 1;
+}	
+
+DWORD WINAPI lineSetTollList(HLINEAPP hLineApp, DWORD dwDeviceID, LPCSTR lpszAddressIn, DWORD dwTollListOption)
+{
+    FIXME(tapi, "(%04x, %08lx, %s, %08lx): stub.\n", hLineApp, dwDeviceID, lpszAddressIn, dwTollListOption);
+    return 0;
+}	
+		
+DWORD WINAPI lineSetupConference(HCALL hCall, HLINE hLine, LPHCALL lphConfCall, LPHCALL lphConsultCall, DWORD dwNumParties, LPLINECALLPARAMS lpCallParams)
+{
+    FIXME(tapi, "(%04x, %04x, %p, %p, %08lx, %p): stub.\n", hCall, hLine, lphConfCall, lphConsultCall, dwNumParties, lpCallParams);
+    return 1;
+}
+
+DWORD WINAPI lineSetupTransfer(HCALL hCall, LPHCALL lphConsultCall, LPLINECALLPARAMS lpCallParams)
+{
+    FIXME(tapi, "(%04x, %p, %p): stub.\n", hCall, lphConsultCall, lpCallParams);
+    return 1;
+}	
+
+DWORD WINAPI lineShutdown(HLINEAPP hLineApp)
+{
+    FIXME(tapi, "(%04x): stub.\n", hLineApp);
+    return 0;
+}
+
+DWORD WINAPI lineSwapHold(HCALL hActiveCall, HCALL hHeldCall)
+{
+    FIXME(tapi, "(active: %04x, held: %04x): stub.\n", hActiveCall, hHeldCall);
+    return 1;
+}
+
+DWORD WINAPI lineTranslateAddress(HLINEAPP hLineApp, DWORD dwDeviceID, DWORD dwAPIVersion, LPCSTR lpszAddressIn, DWORD dwCard, DWORD dwTranslateOptions, LPLINETRANSLATEOUTPUT lpTranslateOutput)
+{
+    FIXME(tapi, "(%04x, %08lx, %08lx, %s, %08lx, %08lx, %p): stub.\n", hLineApp, dwDeviceID, dwAPIVersion, lpszAddressIn, dwCard, dwTranslateOptions, lpTranslateOutput);
+    return 0;
+}
+
+DWORD WINAPI lineTranslateDialog(HLINEAPP hLineApp, DWORD dwDeviceID, DWORD dwAPIVersion, HWND hwndOwner, LPCSTR lpszAddressIn)
+{
+    FIXME(tapi, "(%04x, %08lx, %08lx, %04x, %s): stub.\n", hLineApp, dwDeviceID, dwAPIVersion, hwndOwner, lpszAddressIn);
+    return 0;
+}
+
+DWORD WINAPI lineUncompleteCall(HLINE hLine, DWORD dwCompletionID)
+{
+    FIXME(tapi, "(%04x, %08lx): stub.\n", hLine, dwCompletionID);
+    return 1;
+}
+
+DWORD WINAPI lineUnHold(HCALL hCall)
+{
+    FIXME(tapi, "(%04x): stub.\n", hCall);
+    return 1;
+}
+
+DWORD WINAPI lineUnpark(HLINE hLine, DWORD dwAddressID, LPHCALL lphCall, LPCSTR lpszDestAddress)
+{
+    FIXME(tapi, "(%04x, %08lx, %p, %s): stub.\n", hLine, dwAddressID, lphCall, lpszDestAddress);
+    return 1;
+}	
diff --git a/dlls/tapi32/phone.c b/dlls/tapi32/phone.c
new file mode 100644
index 0000000..0a92cbf
--- /dev/null
+++ b/dlls/tapi32/phone.c
@@ -0,0 +1,206 @@
+/*
+ * TAPI32 phone services
+ *
+ * Copyright 1999  Andreas Mohr
+ */
+
+#include "winbase.h"
+#include "wintypes.h"
+#include "tapi.h"
+#include "debug.h"
+
+static LPPHONE PHONE_Alloc(void)
+{
+}
+
+static LPPHONE PHONE_Get(HPHONE hPhone)
+{	
+}
+
+DWORD WINAPI phoneClose(HPHONE hPhone)
+{
+    FIXME(tapi, "(%04x), stub.\n", hPhone);
+    return 0;
+}
+
+DWORD WINAPI phoneConfigDialog(DWORD dwDeviceID, HWND hwndOwner, LPCSTR lpszDeviceClass)
+{
+    FIXME(tapi, "(%08lx, %04x, %s): stub.\n", dwDeviceID, hwndOwner, lpszDeviceClass);
+    return 0;
+}
+
+DWORD WINAPI phoneDevSpecific(HPHONE hPhone, LPVOID lpParams, DWORD dwSize)
+{
+    FIXME(tapi, "(%04x, %p, %08ld): stub.\n", hPhone, lpParams, dwSize);
+    return 1;
+}
+
+DWORD WINAPI phoneGetButtonInfo(HPHONE hPhone, DWORD dwButtonLampID,
+                                LPPHONEBUTTONINFO lpButtonInfo)
+{
+    FIXME(tapi, "(%04x, %08lx, %p): stub.\n", hPhone, dwButtonLampID, lpButtonInfo);
+    return 0;
+}
+
+DWORD WINAPI phoneGetData(HPHONE hPhone, DWORD dwDataID, LPVOID lpData, DWORD dwSize)
+{
+    FIXME(tapi, "(%04x, %08ld, %p, %08ld): stub.\n", hPhone, dwDataID, lpData, dwSize);
+    return 0;
+}
+
+DWORD WINAPI phoneGetDevCaps(HPHONEAPP hPhoneApp, DWORD dwDeviceID,
+               DWORD dwAPIVersion, DWORD dwExtVersion, LPPHONECAPS lpPhoneCaps)
+{
+    FIXME(tapi, "(%04x, %08ld, %08lx, %08lx, %p): stub.\n", hPhoneApp, dwDeviceID, dwAPIVersion, dwExtVersion, lpPhoneCaps);
+    return 0;
+}
+
+DWORD WINAPI phoneGetDisplay(HPHONE hPhone, LPVARSTRING lpDisplay)
+{
+    FIXME(tapi, "(%04x, %p): stub.\n", hPhone, lpDisplay);
+    return 0;
+}
+
+DWORD WINAPI phoneGetGain(HPHONE hPhone, DWORD dwHookSwitchDev, LPDWORD lpdwGain)
+{
+    FIXME(tapi, "(%04x, %08lx, %p): stub.\n", hPhone, dwHookSwitchDev, lpdwGain);
+    return 0;
+}	
+		
+DWORD WINAPI phoneGetHookSwitch(HPHONE hPhone, LPDWORD lpdwHookSwitchDevs)
+{
+   FIXME(tapi, "(%04x, %p): stub.\n", hPhone, lpdwHookSwitchDevs);
+   return 0;
+}
+
+DWORD WINAPI phoneGetID(HPHONE hPhone, LPVARSTRING lpDeviceID,
+                        LPCSTR lpszDeviceClass)
+{
+    FIXME(tapi, "(%04x, %p, %s): stub.\n", hPhone, lpDeviceID, lpszDeviceClass);    return 0;
+}
+
+DWORD WINAPI phoneGetIcon(DWORD dwDeviceID, LPCSTR lpszDeviceClass,
+		          HICON *lphIcon)
+{
+    FIXME(tapi, "(%08lx, %s, %p): stub.\n", dwDeviceID, lpszDeviceClass, lphIcon);
+    return 0;
+}
+
+DWORD WINAPI phoneGetLamp(HPHONE hPhone, DWORD dwButtonLampID,
+		          LPDWORD lpdwLampMode)
+{
+    FIXME(tapi, "(%04x, %08lx, %p): stub.\n", hPhone, dwButtonLampID, lpdwLampMode);
+    return 0;
+}
+
+DWORD WINAPI phoneGetRing(HPHONE hPhone, LPDWORD lpdwRingMode, LPDWORD lpdwVolume)
+{
+    FIXME(tapi, "(%04x, %p, %p): stub.\n", hPhone, lpdwRingMode, lpdwVolume);
+    return 0;
+}
+
+DWORD WINAPI phoneGetStatus(HPHONE hPhone, LPPHONESTATUS lpPhoneStatus)
+{
+    FIXME(tapi, "(%04x, %p): stub.\n", hPhone, lpPhoneStatus);
+    return 0;
+}
+
+DWORD WINAPI phoneGetStatusMessages(HPHONE hPhone, LPDWORD lpdwPhoneStates,
+		          LPDWORD lpdwButtonModes, LPDWORD lpdwButtonStates)
+{
+    FIXME(tapi, "(%04x, %p, %p, %p): stub.\n", hPhone, lpdwPhoneStates, lpdwButtonModes, lpdwButtonStates);
+    return 0;
+}
+
+DWORD WINAPI phoneGetVolume(HPHONE hPhone, DWORD dwHookSwitchDevs,
+		            LPDWORD lpdwVolume)
+{
+    FIXME(tapi, "(%04x, %08lx, %p): stub.\n", hPhone, dwHookSwitchDevs, lpdwVolume);
+    return 0;
+}
+
+DWORD WINAPI phoneInitialize(LPHPHONEAPP lphPhoneApp, HINSTANCE hInstance, PHONECALLBACK lpfnCallback, LPCSTR lpszAppName, LPDWORD lpdwNumDevs)
+{
+    FIXME(tapi, "(%p, %04x, %p, %s, %p): stub.\n", lphPhoneApp, hInstance, lpfnCallback, lpszAppName, lpdwNumDevs);
+    return 0;
+}
+
+DWORD WINAPI phoneNegotiateAPIVersion(HPHONEAPP hPhoneApp, DWORD dwDeviceID, DWORD dwAPILowVersion, DWORD dwAPIHighVersion, LPDWORD lpdwAPIVersion, LPPHONEEXTENSIONID lpExtensionID)
+{
+    FIXME(tapi, "(): stub.\n");
+    return 0;
+}
+
+DWORD WINAPI phoneNegotiateExtVersion(HPHONEAPP hPhoneApp, DWORD dwDeviceID,
+		                 DWORD dwAPIVersion, DWORD dwExtLowVersion,
+				 DWORD dwExtHighVersion, LPDWORD lpdwExtVersion)
+{
+    FIXME(tapi, "(): stub.\n");
+    return 0;
+}
+
+DWORD WINAPI phoneOpen(HPHONEAPP hPhoneApp, DWORD dwDeviceID, LPHPHONE lphPhone, DWORD dwAPIVersion, DWORD dwExtVersion, DWORD dwCallbackInstance, DWORD dwPrivileges)
+{
+    FIXME(tapi, "(): stub.\n");
+    return 0;
+}
+
+DWORD WINAPI phoneSetButtonInfo(HPHONE hPhone, DWORD dwButtonLampID, LPPHONEBUTTONINFO lpButtonInfo)
+{
+    FIXME(tapi, "(%04x, %08lx, %p): stub.\n", hPhone, dwButtonLampID, lpButtonInfo);
+    return 0;
+}
+
+DWORD WINAPI phoneSetData(HPHONE hPhone, DWORD dwDataID, LPVOID lpData, DWORD dwSize)
+{
+    FIXME(tapi, "(%04x, %08lx, %p, %ld): stub.\n", hPhone, dwDataID, lpData, dwSize);
+    return 1;
+}
+
+DWORD WINAPI phoneSetDisplay(HPHONE hPhone, DWORD dwRow, DWORD dwColumn, LPCSTR lpszDisplay, DWORD dwSize)
+{
+    FIXME(tapi, "(%04x, '%s' at %ld/%ld, len %ld): stub.\n", hPhone, lpszDisplay, dwRow, dwColumn, dwSize);
+    return 1;
+}
+
+DWORD WINAPI phoneSetGain(HPHONE hPhone, DWORD dwHookSwitchDev, DWORD dwGain)
+{
+    FIXME(tapi, "(%04x, %08lx, %ld): stub.\n", hPhone, dwHookSwitchDev, dwGain);
+    return 1;
+}
+
+DWORD WINAPI phoneSetHookSwitch(HPHONE hPhone, DWORD dwHookSwitchDevs, DWORD dwHookSwitchMode)
+{
+    FIXME(tapi, "(%04x, %08lx, %08lx): stub.\n", hPhone, dwHookSwitchDevs, dwHookSwitchMode);
+    return 1;
+}
+
+DWORD WINAPI phoneSetLamp(HPHONE hPhone, DWORD dwButtonLampID, DWORD lpdwLampMode)
+{
+    FIXME(tapi, "(%04x, %08lx, %08lx): stub.\n", hPhone, dwButtonLampID, lpdwLampMode);
+    return 1;
+}
+
+DWORD WINAPI phoneSetRing(HPHONE hPhone, DWORD dwRingMode, DWORD dwVolume)
+{
+    FIXME(tapi, "(%04x, %08lx, %08ld): stub.\n", hPhone, dwRingMode, dwVolume);
+    return 1;
+}
+
+DWORD WINAPI phoneSetStatusMessages(HPHONE hPhone, DWORD dwPhoneStates, DWORD dwButtonModes, DWORD dwButtonStates)
+{
+    FIXME(tapi, "(%04x, %08lx, %08lx, %08lx): stub.\n", hPhone, dwPhoneStates, dwButtonModes, dwButtonStates);
+    return 0; /* FIXME ? */
+}
+
+DWORD WINAPI phoneSetVolume(HPHONE hPhone, DWORD dwHookSwitchDev, DWORD dwVolume)
+{
+    FIXME(tapi, "(%04x, %08lx, %08ld): stub.\n", hPhone, dwHookSwitchDev, dwVolume);
+    return 1;
+}
+
+DWORD WINAPI phoneShutdown(HPHONEAPP hPhoneApp)
+{
+    FIXME(tapi, "(%04x): stub.\n", hPhoneApp);
+    return 0;
+}
diff --git a/include/debug.h b/include/debug.h
index f129e3e..8dc8908 100644
--- a/include/debug.h
+++ b/include/debug.h
@@ -131,33 +131,34 @@
 #define dbch_syscolor 123
 #define dbch_system 124
 #define dbch_tab 125
-#define dbch_task 126
-#define dbch_text 127
-#define dbch_thread 128
-#define dbch_thunk 129
-#define dbch_timer 130
-#define dbch_toolbar 131
-#define dbch_toolhelp 132
-#define dbch_tooltips 133
-#define dbch_trackbar 134
-#define dbch_treeview 135
-#define dbch_ttydrv 136
-#define dbch_tweak 137
-#define dbch_uitools 138
-#define dbch_unknown 139
-#define dbch_updown 140
-#define dbch_ver 141
-#define dbch_virtual 142
-#define dbch_vxd 143
-#define dbch_wave 144
-#define dbch_win 145
-#define dbch_win16drv 146
-#define dbch_win32 147
-#define dbch_wing 148
-#define dbch_winsock 149
-#define dbch_wnet 150
-#define dbch_x11 151
-#define dbch_x11drv 152
+#define dbch_tapi 126
+#define dbch_task 127
+#define dbch_text 128
+#define dbch_thread 129
+#define dbch_thunk 130
+#define dbch_timer 131
+#define dbch_toolbar 132
+#define dbch_toolhelp 133
+#define dbch_tooltips 134
+#define dbch_trackbar 135
+#define dbch_treeview 136
+#define dbch_ttydrv 137
+#define dbch_tweak 138
+#define dbch_uitools 139
+#define dbch_unknown 140
+#define dbch_updown 141
+#define dbch_ver 142
+#define dbch_virtual 143
+#define dbch_vxd 144
+#define dbch_wave 145
+#define dbch_win 146
+#define dbch_win16drv 147
+#define dbch_win32 148
+#define dbch_wing 149
+#define dbch_winsock 150
+#define dbch_wnet 151
+#define dbch_x11 152
+#define dbch_x11drv 153
 /* Definitions for classes identifiers */
 #define dbcl_fixme 0
 #define dbcl_err 1
diff --git a/include/debugdefs.h b/include/debugdefs.h
index 9f9ad39..2e5b986 100644
--- a/include/debugdefs.h
+++ b/include/debugdefs.h
@@ -4,7 +4,7 @@
 #include "debugtools.h"
 #endif
 
-#define DEBUG_CHANNEL_COUNT 153
+#define DEBUG_CHANNEL_COUNT 154
 #ifdef DEBUG_RUNTIME
 short debug_msg_enabled[][DEBUG_CLASS_COUNT] = {
 {1, 1, 0, 0},
@@ -160,6 +160,7 @@
 {1, 1, 0, 0},
 {1, 1, 0, 0},
 {1, 1, 0, 0},
+{1, 1, 0, 0},
 };
 const char* debug_ch_name[] = {
 "accel",
@@ -288,6 +289,7 @@
 "syscolor",
 "system",
 "tab",
+"tapi",
 "task",
 "text",
 "thread",
diff --git a/include/tapi.h b/include/tapi.h
new file mode 100644
index 0000000..a404941
--- /dev/null
+++ b/include/tapi.h
@@ -0,0 +1,626 @@
+/*
+ * TAPI definitions
+ * 
+ * Copyright (c) 1999 Andreas Mohr
+ */
+
+#ifndef __WINE_TAPI_H
+#define __WINE_TAPI_H
+
+#include "windef.h"
+
+typedef HANDLE HCALL, *LPHCALL;
+typedef HANDLE HLINE, *LPHLINE;
+typedef HANDLE HLINEAPP, *LPHLINEAPP;
+typedef HANDLE HPHONE, *LPHPHONE;
+typedef HANDLE HPHONEAPP, *LPHPHONEAPP;
+
+/* FIXME: bogus codes !! */
+#define TAPIERR_REQUESTFAILED   20
+
+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;
+} LINEADDRESSCAPS, *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, *LPLINEADDRESSSTATUS;
+
+typedef struct linedialparams_tag {
+    DWORD dwDialPause;
+    DWORD dwDialSpeed;
+    DWORD dwDigitDuration;
+    DWORD dwWaitForDialtone;
+} LINEDIALPARAMS, *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, *LPLINECALLINFO;
+
+typedef struct linecalllist_tag {
+    DWORD dwTotalSize;
+    DWORD dwNeededSize;
+    DWORD dwUsedSize;
+    DWORD dwCallsNumEntries;
+    DWORD dwCallsSize;
+    DWORD dwCallsOffset;
+} LINECALLLIST, *LPLINECALLLIST;
+
+typedef struct linecallparams_tag {
+    DWORD dwTotalSize;
+    DWORD dwBearerMode;
+    DWORD dwMinRate;
+    DWORD dwMaxRate;
+    DWORD dwMediaMode;
+    DWORD dwCallParamFlags;
+    DWORD dwAddressMode;
+    DWORD dwAddressID;
+    LINEDIALPARAMS DialParams;
+    DWORD dwOrigAddressSize;
+    DWORD dwOrigAddressOffset;
+    DWORD dwDisplayableAddressSize;
+    DWORD dwDisplayableAddressOffset;
+    DWORD dwCalledPartySize;
+    DWORD dwCalledPartyOffset;
+    DWORD dwCommentSize;
+    DWORD dwCommentOffset;
+    DWORD dwUserUserInfoSize;
+    DWORD dwUserUserInfoOffset;
+    DWORD dwHighLevelCompSize;
+    DWORD dwHighLevelCompOffset;
+    DWORD dwLowLevelCompSize;
+    DWORD dwLowLevelCompOffset;
+    DWORD dwDevSpecificSize;
+    DWORD dwDevSpecificOffset;
+} LINECALLPARAMS, *LPLINECALLPARAMS;
+
+typedef struct linecallstatus_tag {
+    DWORD dwTotalSize;
+    DWORD dwNeededSize;
+    DWORD dwUsedSize;
+    DWORD dwCallState;
+    DWORD dwCallStateMode;
+    DWORD dwCallPrivilege;
+    DWORD dwCallFeatures;
+    DWORD dwDevSpecificSize;
+    DWORD dwDevSpecificOffset;
+} LINECALLSTATUS, *LPLINECALLSTATUS;
+
+typedef struct linecountrylist_tag {
+    DWORD dwTotalSize;
+    DWORD dwNeededSize;
+    DWORD dwUsedSize;
+    DWORD dwNumCountries;
+    DWORD dwCountryListSize;
+    DWORD dwCountryListOffset;
+} LINECOUNTRYLIST, *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;
+} LINEDEVCAPS, *LPLINEDEVCAPS;
+
+typedef struct linedevstatus_tag {
+    DWORD dwTotalSize;
+    DWORD dwNeededSize;
+    DWORD dwUsedSize;
+    DWORD dwNumOpens;
+    DWORD dwOpenMediaModes;
+    DWORD dwNumActiveCalls;
+    DWORD dwNumOnHoldCalls;
+    DWORD dwNumOnHoldPendingCalls;
+    DWORD dwLineFeatures;
+    DWORD dwNumCallCompletion;
+    DWORD dwRingMode;
+    DWORD dwSignalLevel;
+    DWORD dwBatteryLevel;
+    DWORD dwRoamMode;
+    DWORD dwDevStatusFlags;
+    DWORD dwTerminalModesSize;
+    DWORD dwTerminalModesOffset;
+    DWORD dwDevSpecificSize;
+    DWORD dwDevSpecificOffset;
+} LINEDEVSTATUS, *LPLINEDEVSTATUS;
+
+typedef struct lineextensionid_tag {
+    DWORD dwExtensionID0;
+    DWORD dwExtensionID1;
+    DWORD dwExtensionID2;
+    DWORD dwExtensionID3;
+} LINEEXTENSIONID, *LPLINEEXTENSIONID;
+
+typedef struct lineforward_tag {
+    DWORD dwForwardMode;
+    DWORD dwCallerAddressSize;
+    DWORD dwCallerAddressOffset;
+    DWORD dwDestCountryCode;
+    DWORD dwDestAddressSize;
+    DWORD dwDestAddressOffset;
+} LINEFORWARD, *LPLINEFORWARD;
+
+typedef struct lineforwardlist_tag {
+    DWORD dwTotalSize;
+    DWORD dwNumEntries;
+    LINEFORWARD ForwardList[1];
+} LINEFORWARDLIST, *LPLINEFORWARDLIST;
+    
+typedef struct linegeneratetone_tag {
+    DWORD dwFrequency;
+    DWORD dwCadenceOn;
+    DWORD dwCadenceOff;
+    DWORD dwVolume;
+} LINEGENERATETONE, *LPLINEGENERATETONE;
+
+typedef struct linemediacontrolcallstate_tag {
+    DWORD dwCallStates;
+    DWORD dwMediaControl;
+} LINEMEDIACONTROLCALLSTATE, *LPLINEMEDIACONTROLCALLSTATE;
+
+typedef struct linemediacontroldigit_tag {
+    DWORD dwDigit;
+    DWORD dwDigitModes;
+    DWORD dwMediaControl;
+} LINEMEDIACONTROLDIGIT, *LPLINEMEDIACONTROLDIGIT;
+
+typedef struct linemediacontrolmedia_tag {
+    DWORD dwMediaModes;
+    DWORD dwDuration;
+    DWORD dwMediaControl;
+} LINEMEDIACONTROLMEDIA, *LPLINEMEDIACONTROLMEDIA;
+
+typedef struct linemediacontroltone_tag {
+    DWORD dwAppSpecific;
+    DWORD dwDuration;
+    DWORD dwFrequency1;
+    DWORD dwFrequency2;
+    DWORD dwFrequency3;
+    DWORD dwMediaControl;
+} LINEMEDIACONTROLTONE, *LPLINEMEDIACONTROLTONE;
+
+typedef struct linemonitortone_tag {
+    DWORD dwAppSpecific;
+    DWORD dwDuration;
+    DWORD dwFrequency1;
+    DWORD dwFrequency2;
+    DWORD dwFrequency3;
+} LINEMONITORTONE, *LPLINEMONITORTONE;
+
+typedef struct lineproviderlist_tag {
+    DWORD dwTotalSize;
+    DWORD dwNeededSize;
+    DWORD dwUsedSize;
+    DWORD dwNumProviders;
+    DWORD dwProviderListSize;
+    DWORD dwProviderListOffset;
+} LINEPROVIDERLIST, *LPLINEPROVIDERLIST;
+
+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, *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, *LPLINETRANSLATEOUTPUT;
+
+typedef void (CALLBACK * LINECALLBACK)(DWORD, DWORD, DWORD, DWORD, DWORD, DWORD);
+
+typedef struct _PHONEAPP {
+} PHONEAPP, *LPPHONEAPP;
+
+typedef struct _PHONE {
+    DWORD dwRingMode;
+    DWORD dwVolume;
+} PHONE, *LPPHONE;
+
+typedef struct phonebuttoninfo_tag {
+    DWORD dwTotalSize;
+    DWORD dwNeededSize;
+    DWORD dwUsedSize;
+    DWORD dwButtonMode;
+    DWORD dwButtonFunction;
+    DWORD dwButtonTextSize;
+    DWORD dwButtonTextOffset;
+    DWORD dwDevSpecificSize;
+    DWORD dwDevSpecificOffset;
+    DWORD dwButtonState;
+} PHONEBUTTONINFO, *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;
+} PHONECAPS, *LPPHONECAPS;
+
+typedef struct phoneextensionid_tag {
+    DWORD dwExtensionID0;
+    DWORD dwExtensionID1;
+    DWORD dwExtensionID2;
+    DWORD dwExtensionID3;
+} PHONEEXTENSIONID, *LPPHONEEXTENSIONID;
+
+typedef struct phonestatus_tag {
+    DWORD dwTotalSize;
+    DWORD dwNeededSize;
+    DWORD dwUsedSize;
+    DWORD dwStatusFlags;
+    DWORD dwNumOwners;
+    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, *LPPHONESTATUS;
+
+typedef void (CALLBACK * PHONECALLBACK)(HANDLE, DWORD, DWORD, DWORD, DWORD, DWORD);
+
+typedef struct varstring_tag {
+    DWORD dwTotalSize;
+    DWORD dwNeededSize;
+    DWORD dwUsedSize;
+    DWORD dwStringFormat;
+    DWORD dwStringSize;
+    DWORD dwStringOffset;
+} VARSTRING, *LPVARSTRING;
+
+/* line functions */
+DWORD WINAPI lineAccept(HCALL,LPCSTR,DWORD);
+DWORD WINAPI lineAddProvider(LPCSTR,HWND,LPDWORD);
+DWORD WINAPI lineAddToConference(HCALL,HCALL);
+DWORD WINAPI lineAnswer(HCALL,LPCSTR,DWORD);
+DWORD WINAPI lineBlindTransfer(HCALL,LPCSTR,DWORD);
+DWORD WINAPI lineClose(HLINE);
+DWORD WINAPI lineCompleteCall(HCALL,LPDWORD,DWORD,DWORD);
+DWORD WINAPI lineCompleteTransfer(HCALL,HCALL,LPHCALL,DWORD);
+DWORD WINAPI lineConfigDialog(DWORD,HWND,LPCSTR);
+DWORD WINAPI lineConfigDialogEdit(DWORD,HWND,LPCSTR,LPVOID const,DWORD,LPVARSTRING);
+DWORD WINAPI lineConfigProvider(HWND,DWORD);
+DWORD WINAPI lineDeallocateCall(HCALL);
+DWORD WINAPI lineDevSpecific(HLINE,DWORD,HCALL,LPVOID,DWORD);
+DWORD WINAPI lineDevSpecificFeature(HLINE,DWORD,LPVOID,DWORD);
+DWORD WINAPI lineDial(HCALL,LPCSTR,DWORD);
+DWORD WINAPI lineDrop(HCALL,LPCSTR,DWORD);
+DWORD WINAPI lineForward(HLINE,DWORD,DWORD,LPLINEFORWARDLIST,DWORD,LPHCALL,LPLINECALLPARAMS);
+DWORD WINAPI lineGatherDigits(HCALL,DWORD,LPSTR,DWORD,LPCSTR,DWORD,DWORD);
+DWORD WINAPI lineGenerateDigits(HCALL,DWORD,LPCSTR,DWORD);
+DWORD WINAPI lineGenerateTone(HCALL,DWORD,DWORD,DWORD,LPLINEGENERATETONE);
+DWORD WINAPI lineGetAddressCaps(HLINEAPP,DWORD,DWORD,DWORD,DWORD,LPLINEADDRESSCAPS);
+DWORD WINAPI lineGetAddressID(HLINE,LPDWORD,DWORD,LPCSTR,DWORD);
+DWORD WINAPI lineGetAddressStatus(HLINE,DWORD,LPLINEADDRESSSTATUS);
+DWORD WINAPI lineGetAppPriority(LPCSTR,DWORD,LPLINEEXTENSIONID const,DWORD,LPVARSTRING,LPDWORD);
+DWORD WINAPI lineGetCallInfo(HCALL,LPLINECALLINFO);
+DWORD WINAPI lineGetCallStatus(HCALL,LPLINECALLSTATUS);
+DWORD WINAPI lineGetConfRelatedCalls(HCALL,LPLINECALLLIST);
+DWORD WINAPI lineGetCountry(DWORD,DWORD,LPLINECOUNTRYLIST);
+DWORD WINAPI lineGetDevCaps(HLINEAPP,DWORD,DWORD,DWORD,LPLINEDEVCAPS);
+DWORD WINAPI lineGetDevConfig(DWORD,LPVARSTRING,LPCSTR);
+DWORD WINAPI lineGetID(HLINE,DWORD,HCALL,DWORD,LPVARSTRING,LPCSTR);
+DWORD WINAPI lineGetIcon(DWORD,LPCSTR,HICON *);
+DWORD WINAPI lineGetLineDevStatus(HLINE,LPLINEDEVSTATUS);
+DWORD WINAPI lineGetNewCalls(HLINE,DWORD,DWORD,LPLINECALLLIST);
+DWORD WINAPI lineGetNumRings(HLINE,DWORD,LPDWORD);
+DWORD WINAPI lineGetProviderList(DWORD dwAPIVersion,LPLINEPROVIDERLIST);
+DWORD WINAPI lineGetRequest(HLINEAPP,DWORD,LPVOID);
+DWORD WINAPI lineGetStatusMessages(HLINE,LPDWORD,LPDWORD);
+DWORD WINAPI lineGetTranslateCaps(HLINEAPP,DWORD,LPLINETRANSLATECAPS);
+DWORD WINAPI lineHandoff(HCALL,LPCSTR,DWORD);
+DWORD WINAPI lineHold(HCALL);
+DWORD WINAPI lineInitialize(LPHLINEAPP,HINSTANCE,LINECALLBACK,LPCSTR,LPDWORD);
+DWORD WINAPI lineMakeCall(HLINE,LPHCALL,LPCSTR,DWORD,LPLINECALLPARAMS);
+DWORD WINAPI lineMonitorDigits(HCALL,DWORD);
+DWORD WINAPI lineMonitorMedia(HCALL,DWORD);
+DWORD WINAPI lineMonitorTones(HCALL,LPLINEMONITORTONE,DWORD);
+DWORD WINAPI lineNegotiateAPIVersion(HLINEAPP,DWORD,DWORD,DWORD,LPDWORD,LPLINEEXTENSIONID);
+DWORD WINAPI lineNegotiateExtVersion(HLINEAPP,DWORD,DWORD,DWORD,DWORD,LPDWORD);
+DWORD WINAPI lineOpen(HLINEAPP,DWORD,LPHLINE,DWORD,DWORD,DWORD,DWORD,DWORD,LPLINECALLPARAMS);
+DWORD WINAPI linePark(HCALL,DWORD,LPCSTR,LPVARSTRING);
+DWORD WINAPI linePickup(HLINE,DWORD,LPHCALL,LPCSTR,LPCSTR);
+DWORD WINAPI linePrepareAddToConference(HCALL,LPHCALL,LPLINECALLPARAMS);
+DWORD WINAPI lineRedirect(HCALL,LPCSTR,DWORD);
+DWORD WINAPI lineRegisterRequestRecipient(HLINEAPP,DWORD,DWORD,DWORD);
+DWORD WINAPI lineReleaseUserUserInfo(HCALL);
+DWORD WINAPI lineRemoveFromConference(HCALL);
+DWORD WINAPI lineRemoveProvider(DWORD,HWND);
+DWORD WINAPI lineSecureCall(HCALL);
+DWORD WINAPI lineSendUserUserInfo(HCALL,LPCSTR,DWORD);
+DWORD WINAPI lineSetAppPriority(LPCSTR,DWORD,LPLINEEXTENSIONID const,DWORD,LPCSTR,DWORD);
+DWORD WINAPI lineSetAppSpecific(HCALL,DWORD);
+DWORD WINAPI lineSetCallParams(HCALL,DWORD,DWORD,DWORD,LPLINEDIALPARAMS);
+DWORD WINAPI lineSetCallPrivilege(HCALL,DWORD);
+DWORD WINAPI lineSetCurrentLocation(HLINEAPP,DWORD);
+DWORD WINAPI lineSetDevConfig(DWORD,LPVOID,DWORD,LPCSTR);
+DWORD WINAPI lineSetMediaControl(HLINE,DWORD,HCALL,DWORD,LPLINEMEDIACONTROLDIGIT,DWORD,LPLINEMEDIACONTROLMEDIA,DWORD,LPLINEMEDIACONTROLTONE,DWORD,LPLINEMEDIACONTROLCALLSTATE,DWORD);
+DWORD WINAPI lineSetMediaMode(HCALL,DWORD);
+DWORD WINAPI lineSetNumRings(HLINE,DWORD,DWORD);
+DWORD WINAPI lineSetStatusMessages(HLINE,DWORD,DWORD);
+DWORD WINAPI lineSetTerminal(HLINE,DWORD,HCALL,DWORD,DWORD,DWORD,DWORD);
+DWORD WINAPI lineSetTollList(HLINEAPP,DWORD,LPCSTR,DWORD);
+DWORD WINAPI lineSetupConference(HCALL,HLINE,LPHCALL,LPHCALL,DWORD,LPLINECALLPARAMS);
+DWORD WINAPI lineSetupTransfer(HCALL,LPHCALL,LPLINECALLPARAMS);
+DWORD WINAPI lineShutdown(HLINEAPP);
+DWORD WINAPI lineSwapHold(HCALL,HCALL);
+DWORD WINAPI lineTranslateAddress(HLINEAPP,DWORD,DWORD,LPCSTR,DWORD,DWORD,LPLINETRANSLATEOUTPUT);
+DWORD WINAPI lineTranslateDialog(HLINEAPP,DWORD,DWORD,HWND,LPCSTR);
+DWORD WINAPI lineUncompleteCall(HLINE,DWORD);
+DWORD WINAPI lineUnHold(HCALL);
+DWORD WINAPI lineUnpark(HLINE,DWORD,LPHCALL,LPCSTR);
+
+/* phone functions */
+DWORD WINAPI phoneClose(HPHONE);
+DWORD WINAPI phoneConfigDialog(DWORD,HWND,LPCSTR);
+DWORD WINAPI phoneDevSpecific(HPHONE,LPVOID,DWORD);
+DWORD WINAPI phoneGetButtonInfo(HPHONE,DWORD,LPPHONEBUTTONINFO);
+DWORD WINAPI phoneGetData(HPHONE,DWORD,LPVOID,DWORD);
+DWORD WINAPI phoneGetDevCaps(HPHONEAPP,DWORD,DWORD,DWORD,LPPHONECAPS);
+DWORD WINAPI phoneGetDisplay(HPHONE,LPVARSTRING);
+DWORD WINAPI phoneGetHookSwitch(HPHONE,LPDWORD);
+DWORD WINAPI phoneGetID(HPHONE,LPVARSTRING,LPCSTR);
+DWORD WINAPI phoneGetIcon(DWORD,LPCSTR,HICON *);
+DWORD WINAPI phoneGetLamp(HPHONE,DWORD,LPDWORD);
+DWORD WINAPI phoneGetRing(HPHONE,LPDWORD,LPDWORD);
+DWORD WINAPI phoneGetStatus(HPHONE,LPPHONESTATUS);
+DWORD WINAPI phoneGetStatusMessages(HPHONE,LPDWORD,LPDWORD,LPDWORD);
+DWORD WINAPI phoneGetVolume(HPHONE,DWORD,LPDWORD);
+DWORD WINAPI phoneInitialize(LPHPHONEAPP,HINSTANCE,PHONECALLBACK,LPCSTR,LPDWORD);
+DWORD WINAPI phoneNegotiateAPIVersion(HPHONEAPP,DWORD,DWORD,DWORD,LPDWORD,LPPHONEEXTENSIONID);
+DWORD WINAPI phoneNegotiateExtVersion(HPHONEAPP,DWORD,DWORD,DWORD,DWORD,LPDWORD);
+DWORD WINAPI phoneOpen(HPHONEAPP,DWORD,LPHPHONE,DWORD,DWORD,DWORD,DWORD);
+DWORD WINAPI phoneSetButtonInfo(HPHONE,DWORD,LPPHONEBUTTONINFO);
+DWORD WINAPI phoneSetData(HPHONE,DWORD,LPVOID,DWORD);
+DWORD WINAPI phoneSetDisplay(HPHONE,DWORD,DWORD,LPCSTR,DWORD);
+DWORD WINAPI phoneSetGain(HPHONE,DWORD,DWORD);
+DWORD WINAPI phoneSetHookSwitch(HPHONE,DWORD,DWORD);
+DWORD WINAPI phoneSetLamp(HPHONE,DWORD,DWORD);
+DWORD WINAPI phoneSetRing(HPHONE,DWORD,DWORD);
+DWORD WINAPI phoneSetStatusMessages(HPHONE,DWORD,DWORD,DWORD);
+DWORD WINAPI phoneSetVolume(HPHONE,DWORD,DWORD);
+DWORD WINAPI phoneShutdown(HPHONEAPP);
+
+/* "assisted" functions */
+DWORD WINAPI tapiGetLocationInfo(LPSTR,LPSTR);
+DWORD WINAPI tapiRequestMakeCall(LPCSTR,LPCSTR,LPCSTR,LPCSTR);
+
+#endif /* __WINE_TAPI_H */
diff --git a/misc/Makefile.in b/misc/Makefile.in
index 2c4c232..b99b404 100644
--- a/misc/Makefile.in
+++ b/misc/Makefile.in
@@ -29,7 +29,6 @@
 	stress.c \
 	string.c \
 	system.c \
-	tapi32.c \
 	toolhelp.c \
 	tweak.c \
 	version.c \
diff --git a/misc/tapi32.c b/misc/tapi32.c
deleted file mode 100644
index 331518d..0000000
--- a/misc/tapi32.c
+++ /dev/null
@@ -1,76 +0,0 @@
-/*
- * TAPI32
- *
- * Copyright (c) 1998 Andreas Mohr
- */
-
-#include <string.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include "wintypes.h"
-#include "debug.h"
-
-UINT WINAPI lineInitialize(
-  LPVOID lphLineApp, /* FIXME */
-  HINSTANCE hInstance,
-  LPVOID lpfnCallback, /* FIXME */
-  LPCSTR lpszAppName,
-  LPDWORD lpdwNumDevs)
-{
-    FIXME(comm, "stub.\n");
-    return 0;
-}
-
-UINT WINAPI lineShutdown( HANDLE hLineApp ) /* FIXME */
-{
-    FIXME(comm, "stub.\n");
-    return 0;
-}
-
-UINT WINAPI lineNegotiateAPIVersion(
-  HANDLE hLineApp, /* FIXME */
-  DWORD dwDeviceID,
-  DWORD dwAPILowVersion,
-  DWORD dwAPIHighVersion,
-  LPDWORD lpdwAPIVersion,
-  LPVOID lpExtensionID /* FIXME */
-)
-{
-    FIXME(comm, "stub.\n");
-    *lpdwAPIVersion = dwAPIHighVersion;
-    return 0;
-}
-
-/*************************************************************************
- * lineRedirect32 [TAPI32.53]
- * 
- */
-LONG WINAPI lineRedirect(
-  HANDLE* hCall,
-  LPCSTR lpszDestAddress,
-  DWORD  dwCountryCode) {
-
-  FIXME(comm, ": stub.\n");
-  return -1;
-/*  return LINEERR_OPERATIONFAILED; */
-}
-
-/*************************************************************************
- * tapiRequestMakeCall32 [TAPI32.113]
- * 
- */
-LONG WINAPI tapiRequestMakeCall(
-  LPCSTR lpszDestAddress,
-  LPCSTR lpszAppName,
-  LPCSTR lpszCalledParty,
-  LPCSTR lpszComment) {
-
-  FIXME(comm, ": stub.\n");
-  return -1;
-/*  return TAPIERR_REQUESTQUEUEFULL; */
-}
-
-
-
-
-
diff --git a/relay32/tapi32.spec b/relay32/tapi32.spec
index 7664a25..e418c59 100644
--- a/relay32/tapi32.spec
+++ b/relay32/tapi32.spec
@@ -1,117 +1,127 @@
 name	tapi32
 type	win32
 
-  1 stub    lineAccept
-  2 stub    lineAddProvider
-  3 stub    lineAddToConference
-  4 stub    lineAnswer
-  5 stub    lineBlindTransfer
-  6 stub    lineClose
-  7 stub    lineCompleteCall
-  8 stub    lineCompleteTransfer
-  9 stub    lineConfigDialog
- 10 stub    lineConfigDialogEdit
- 11 stub    lineConfigProvider
- 12 stub    lineDeallocateCall
- 13 stub    lineDevSpecific
- 14 stub    lineDevSpecificFeature
- 15 stub    lineDial
- 16 stub    lineDrop
- 17 stub    lineForward
- 18 stub    lineGatherDigits
- 19 stub    lineGenerateDigits
- 20 stub    lineGenerateTone
- 21 stub    lineGetAddressCaps
- 22 stub    lineGetAddressID
- 23 stub    lineGetAddressStatus
- 24 stub    lineGetAppPriority
- 25 stub    lineGetCallInfo
- 26 stub    lineGetCallStatus
- 27 stub    lineGetConfRelatedCalls
- 28 stub    lineGetCountry
- 29 stub    lineGetDevCaps
- 30 stub    lineGetDevConfig
- 31 stub    lineGetID
- 32 stub    lineGetIcon
- 33 stub    lineGetLineDevStatus
- 34 stub    lineGetNewCalls
- 35 stub    lineGetNumRings
- 36 stub    lineGetProviderList
- 37 stub    lineGetRequest
- 38 stub    lineGetStatusMessages
- 39 stub    lineGetTranslateCaps
- 40 stub    lineHandoff
- 41 stub    lineHold
+  1 stdcall lineAccept(long str long) lineAccept
+  2 stdcall lineAddProvider(str long ptr) lineAddProvider
+  3 stdcall lineAddToConference(long long) lineAddToConference
+  4 stdcall lineAnswer(long str long) lineAnswer
+  5 stdcall lineBlindTransfer(long str long) lineBlindTransfer
+  6 stdcall lineClose(long) lineClose
+  7 stdcall lineCompleteCall(long ptr long long) lineCompleteCall
+  8 stdcall lineCompleteTransfer(long long ptr long) lineCompleteTransfer
+  9 stdcall lineConfigDialog(long long str) lineConfigDialog
+ 10 stdcall lineConfigDialogEdit(long long str ptr long ptr)
+ lineConfigDialogEdit
+ 11 stdcall lineConfigProvider(long long) lineConfigProvider
+ 12 stdcall lineDeallocateCall(long) lineDeallocateCall
+ 13 stdcall lineDevSpecific(long long long ptr long) lineDevSpecific
+ 14 stdcall lineDevSpecificFeature(long long ptr long) lineDevSpecificFeature
+ 15 stdcall lineDial(long str long) lineDial
+ 16 stdcall lineDrop(long str long) lineDrop
+ 17 stdcall lineForward(long long long ptr long ptr ptr) lineForward
+ 18 stdcall lineGatherDigits(long long str long str long long)
+ lineGatherDigits
+ 19 stdcall lineGenerateDigits(long long str long) lineGenerateDigits
+ 20 stdcall lineGenerateTone(long long long long ptr) lineGenerateTone
+ 21 stdcall lineGetAddressCaps(long long long long long ptr)
+ lineGetAddressCaps
+ 22 stdcall lineGetAddressID(long ptr long str long) lineGetAddressID
+ 23 stdcall lineGetAddressStatus(long long ptr) lineGetAddressStatus
+ 24 stdcall lineGetAppPriority(str long ptr long ptr ptr) lineGetAppPriority
+ 25 stdcall lineGetCallInfo(long ptr) lineGetCallInfo
+ 26 stdcall lineGetCallStatus(long ptr) lineGetCallStatus
+ 27 stdcall lineGetConfRelatedCalls(long ptr) lineGetConfRelatedCalls
+ 28 stdcall lineGetCountry(long long ptr) lineGetCountry
+ 29 stdcall lineGetDevCaps(long long long long ptr) lineGetDevCaps
+ 30 stdcall lineGetDevConfig(long ptr str) lineGetDevConfig
+ 31 stdcall lineGetID(long long long long ptr str) lineGetID
+ 32 stdcall lineGetIcon(long str ptr) lineGetIcon
+ 33 stdcall lineGetLineDevStatus(long ptr) lineGetLineDevStatus
+ 34 stdcall lineGetNewCalls(long long long ptr) lineGetNewCalls
+ 35 stdcall lineGetNumRings(long long ptr) lineGetNumRings
+ 36 stdcall lineGetProviderList(long ptr) lineGetProviderList
+ 37 stdcall lineGetRequest(long long ptr) lineGetRequest
+ 38 stdcall lineGetStatusMessages(long ptr ptr) lineGetStatusMessages
+ 39 stdcall lineGetTranslateCaps(long long ptr) lineGetTranslateCaps
+ 40 stdcall lineHandoff(long str long) lineHandoff
+ 41 stdcall lineHold(long) lineHold
  42 stdcall lineInitialize(ptr long ptr str ptr) lineInitialize
- 43 stub    lineMakeCall
- 44 stub    lineMonitorDigits
- 45 stub    lineMonitorMedia
- 46 stub    lineMonitorTones
+ 43 stdcall lineMakeCall(long ptr str long ptr) lineMakeCall
+ 44 stdcall lineMonitorDigits(long long) lineMonitorDigits
+ 45 stdcall lineMonitorMedia(long long) lineMonitorMedia
+ 46 stdcall lineMonitorTones(long ptr long) lineMonitorTones
  47 stdcall lineNegotiateAPIVersion(long long long long ptr ptr) lineNegotiateAPIVersion
- 48 stub    lineNegotiateExtVersion
- 49 stub    lineOpen
- 50 stub    linePark
- 51 stub    linePickup
- 52 stub    linePrepareAddToConference
- 53 stdcall lineRedirect(long ptr long) lineRedirect
- 54 stub    lineRegisterRequestRecipient
- 55 stub    lineReleaseUserUserInfo
- 56 stub    lineRemoveFromConference
- 57 stub    lineRemoveProvider
- 58 stub    lineSecureCall
- 59 stub    lineSendUserUserInfo
- 60 stub    lineSetAppPriority
- 61 stub    lineSetAppSpecific
- 62 stub    lineSetCallParams
- 63 stub    lineSetCallPrivilege
- 64 stub    lineSetCurrentLocation
- 65 stub    lineSetDevConfig
- 66 stub    lineSetMediaControl
- 67 stub    lineSetMediaMode
- 68 stub    lineSetNumRings
- 69 stub    lineSetStatusMessages
- 70 stub    lineSetTerminal
- 71 stub    lineSetTollList
- 72 stub    lineSetupConference
- 73 stub    lineSetupTransfer
+ 48 stdcall lineNegotiateExtVersion(long long long long long ptr)
+ lineNegotiateExtVersion
+ 49 stdcall lineOpen(long long ptr long long long long long ptr) lineOpen
+ 50 stdcall linePark(long long str ptr) linePark
+ 51 stdcall linePickup(long long ptr str str) linePickup
+ 52 stdcall linePrepareAddToConference(long ptr ptr) linePrepareAddToConference
+ 53 stdcall lineRedirect(long str long) lineRedirect
+ 54 stdcall lineRegisterRequestRecipient(long long long long)
+ lineRegisterRequestRecipient
+ 55 stdcall lineReleaseUserUserInfo(long) lineReleaseUserUserInfo
+ 56 stdcall lineRemoveFromConference(long) lineRemoveFromConference
+ 57 stdcall lineRemoveProvider(long long) lineRemoveProvider
+ 58 stdcall lineSecureCall(long) lineSecureCall
+ 59 stdcall lineSendUserUserInfo(long str long) lineSendUserUserInfo
+ 60 stdcall lineSetAppPriority(str long ptr long str long) lineSetAppPriority
+ 61 stdcall lineSetAppSpecific(long long) lineSetAppSpecific
+ 62 stdcall lineSetCallParams(long long long long ptr) lineSetCallParams
+ 63 stdcall lineSetCallPrivilege(long long) lineSetCallPrivilege
+ 64 stdcall lineSetCurrentLocation(long long) lineSetCurrentLocation
+ 65 stdcall lineSetDevConfig(long ptr long str) lineSetDevConfig
+ 66 stdcall lineSetMediaControl(long long long long ptr) lineSetMediaControl
+ 67 stdcall lineSetMediaMode(long long) lineSetMediaMode
+ 68 stdcall lineSetNumRings(long long long) lineSetNumRings
+ 69 stdcall lineSetStatusMessages(long long long) lineSetStatusMessages
+ 70 stdcall lineSetTerminal(long long long long long long long)
+ lineSetTerminal
+ 71 stdcall lineSetTollList(long long str long) lineSetTollList
+ 72 stdcall lineSetupConference(long long ptr ptr long ptr)
+ lineSetupConference
+ 73 stdcall lineSetupTransfer(long ptr ptr) lineSetupTransfer
  74 stdcall lineShutdown(long) lineShutdown
- 75 stub    lineSwapHold
- 76 stub    lineTranslateAddress
- 77 stub    lineTranslateDialog
- 78 stub    lineUncompleteCall
- 79 stub    lineUnhold
- 80 stub    lineUnpark
- 81 stub    phoneClose
- 82 stub    phoneConfigDialog
- 83 stub    phoneDevSpecific
- 84 stub    phoneGetButtonInfo
- 85 stub    phoneGetData
- 86 stub    phoneGetDevCaps
- 87 stub    phoneGetDisplay
- 88 stub    phoneGetGain
- 89 stub    phoneGetHookSwitch
- 90 stub    phoneGetID
- 91 stub    phoneGetIcon
- 92 stub    phoneGetLamp
- 93 stub    phoneGetRing
- 94 stub    phoneGetStatus
- 95 stub    phoneGetStatusMessages
- 96 stub    phoneGetVolume
- 97 stub    phoneInitialize
- 98 stub    phoneNegotiateAPIVersion
- 99 stub    phoneNegotiateExtVersion
-100 stub    phoneOpen
-101 stub    phoneSetButtonInfo
-102 stub    phoneSetData
-103 stub    phoneSetDisplay
-104 stub    phoneSetGain
-105 stub    phoneSetHookSwitch
-106 stub    phoneSetLamp
-107 stub    phoneSetRing
-108 stub    phoneSetStatusMessages
-109 stub    phoneSetVolume
-110 stub    phoneShutdown
-111 stub    tapiGetLocationInfo
+ 75 stdcall lineSwapHold(long long) lineSwapHold
+ 76 stdcall lineTranslateAddress(long long long str long long ptr)
+ lineTranslateAddress
+ 77 stdcall lineTranslateDialog(long long long long str) lineTranslateDialog
+ 78 stdcall lineUncompleteCall(long long) lineUncompleteCall
+ 79 stdcall lineUnHold(long) lineUnHold
+ 80 stdcall lineUnpark(long long ptr str) lineUnpark
+ 81 stdcall phoneClose(long) phoneClose
+ 82 stdcall phoneConfigDialog(long long str) phoneConfigDialog
+ 83 stdcall phoneDevSpecific(long ptr long) phoneDevSpecific
+ 84 stdcall phoneGetButtonInfo(long long ptr) phoneGetButtonInfo
+ 85 stdcall phoneGetData(long long ptr long) phoneGetData
+ 86 stdcall phoneGetDevCaps(long long long long ptr) phoneGetDevCaps
+ 87 stdcall phoneGetDisplay(long ptr) phoneGetDisplay
+ 88 stdcall phoneGetGain(long long ptr) phoneGetGain
+ 89 stdcall phoneGetHookSwitch(long ptr) phoneGetHookSwitch
+ 90 stdcall phoneGetID(long ptr str) phoneGetID
+ 91 stdcall phoneGetIcon(long str ptr) phoneGetIcon
+ 92 stdcall phoneGetLamp(long long ptr) phoneGetLamp
+ 93 stdcall phoneGetRing(long ptr ptr) phoneGetRing
+ 94 stdcall phoneGetStatus(long ptr) phoneGetStatus
+ 95 stdcall phoneGetStatusMessages(long ptr ptr ptr) phoneGetStatusMessages
+ 96 stdcall phoneGetVolume(long long ptr) phoneGetVolume
+ 97 stdcall phoneInitialize(ptr long ptr str ptr) phoneInitialize
+ 98 stdcall phoneNegotiateAPIVersion(long long long long long ptr ptr)
+ phoneNegotiateAPIVersion
+ 99 stdcall phoneNegotiateExtVersion(long long long long long ptr)
+ phoneNegotiateExtVersion
+100 stdcall phoneOpen(long long ptr long long long long) phoneOpen
+101 stdcall phoneSetButtonInfo(long long ptr) phoneSetButtonInfo
+102 stdcall phoneSetData(long long ptr long) phoneSetData
+103 stdcall phoneSetDisplay(long long long str long) phoneSetDisplay
+104 stdcall phoneSetGain(long long long) phoneSetGain
+105 stdcall phoneSetHookSwitch(long long long) phoneSetHookSwitch
+106 stdcall phoneSetLamp(long long long) phoneSetLamp
+107 stdcall phoneSetRing(long long long) phoneSetRing
+108 stdcall phoneSetStatusMessages(long long long long) phoneSetStatusMessages
+109 stdcall phoneSetVolume(long long long) phoneSetVolume
+110 stdcall phoneShutdown(long) phoneShutdown
+111 stdcall tapiGetLocationInfo(str str) tapiGetLocationInfo
 112 stub    tapiRequestDrop
 113 stdcall tapiRequestMakeCall(str str str str) tapiRequestMakeCall
 114 stub    tapiRequestMediaCall