dll/win32/tapi32/line.c

   1 /*
   2  * TAPI32 line services
   3  *
   4  * Copyright 1999  Andreas Mohr
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include <string.h>
  22 #include <stdlib.h>
  23 #include <stdarg.h>
  24 #include <stdio.h>
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "wingdi.h"
  28 #include "winreg.h"
  29 #include "winnls.h"
  30 #include "winerror.h"
  31 #include "objbase.h"
  32 #include "tapi.h"
  33 #include "wine/debug.h"
  34 #include "wine/unicode.h"
  35
  36 WINE_DEFAULT_DEBUG_CHANNEL(tapi);
  37
  38 /* registry keys */
  39 static const char szCountrylistKey[] =
  40     "Software\\Microsoft\\Windows\\CurrentVersion\\Telephony\\Country List";
  41 static const char szLocationsKey[] =
  42     "Software\\Microsoft\\Windows\\CurrentVersion\\Telephony\\Locations";
  43 static const char szCardsKey[] =
  44     "Software\\Microsoft\\Windows\\CurrentVersion\\Telephony\\Cards";
  45
  46
  47 /***********************************************************************
  48  *              lineAccept (TAPI32.@)
  49  */
  50 DWORD WINAPI lineAccept(HCALL hCall, LPCSTR lpsUserUserInfo, DWORD dwSize)
  51 {
  52     FIXME("(%p, %s, %d): stub.\n", hCall, lpsUserUserInfo, dwSize);
  53     return 1;
  54 }
  55
  56 /***********************************************************************
  57  *              lineAddProviderA (TAPI32.@)
  58  */
  59 DWORD WINAPI lineAddProviderA(LPCSTR lpszProviderName, HWND hwndOwner, LPDWORD lpdwPermanentProviderID)
  60 {
  61     FIXME("(%s, %p, %p): stub.\n", lpszProviderName, hwndOwner, lpdwPermanentProviderID);
  62     return LINEERR_OPERATIONFAILED;
  63 }
  64
  65 /***********************************************************************
  66  *              lineAddProviderW (TAPI32.@)
  67  */
  68 DWORD WINAPI lineAddProviderW(LPCWSTR lpszProviderName, HWND hwndOwner, LPDWORD lpdwPermanentProviderID)
  69 {
  70     FIXME("(%s, %p, %p): stub.\n", wine_dbgstr_w(lpszProviderName), hwndOwner, lpdwPermanentProviderID);
  71     return LINEERR_OPERATIONFAILED;
  72 }
  73
  74 /***********************************************************************
  75  *              lineAddToConference (TAPI32.@)
  76  */
  77 DWORD WINAPI lineAddToConference(HCALL hConfCall, HCALL hConsultCall)
  78 {
  79     FIXME("(%p, %p): stub.\n", hConfCall, hConsultCall);
  80     return 1;
  81 }
  82
  83 /***********************************************************************
  84  *              lineAnswer (TAPI32.@)
  85  */
  86 DWORD WINAPI lineAnswer(HCALL hCall, LPCSTR lpsUserUserInfo, DWORD dwSize)
  87 {
  88     FIXME("(%p, %s, %d): stub.\n", hCall, lpsUserUserInfo, dwSize);
  89     return 1;
  90 }
  91
  92 /***********************************************************************
  93  *              lineBlindTransfer (TAPI32.@)
  94  */
  95 DWORD WINAPI lineBlindTransferA(HCALL hCall, LPCSTR lpszDestAddress, DWORD dwCountryCode)
  96 {
  97     FIXME("(%p, %s, %08x): stub.\n", hCall, lpszDestAddress, dwCountryCode);
  98     return 1;
  99 }
 100
 101 /***********************************************************************
 102  *              lineClose (TAPI32.@)
 103  */
 104 DWORD WINAPI lineClose(HLINE hLine)
 105 {
 106     FIXME("(%p): stub.\n", hLine);
 107     return 0;
 108 }
 109
 110 /***********************************************************************
 111  *              lineCompleteCall (TAPI32.@)
 112  */
 113 DWORD WINAPI lineCompleteCall(HCALL hCall, LPDWORD lpdwCompletionID, DWORD dwCompletionMode, DWORD dwMessageID)
 114 {
 115     FIXME("(%p, %p, %08x, %08x): stub.\n", hCall, lpdwCompletionID, dwCompletionMode, dwMessageID);
 116     return 1;
 117 }
 118
 119 /***********************************************************************
 120  *              lineCompleteTransfer (TAPI32.@)
 121  */
 122 DWORD WINAPI lineCompleteTransfer(HCALL hCall, HCALL hConsultCall, LPHCALL lphConfCall, DWORD dwTransferMode)
 123 {
 124     FIXME("(%p, %p, %p, %08x): stub.\n", hCall, hConsultCall, lphConfCall, dwTransferMode);
 125     return 1;
 126 }
 127
 128 /***********************************************************************
 129  *              lineConfigDialog (TAPI32.@)
 130  */
 131 DWORD WINAPI lineConfigDialogA(DWORD dwDeviceID, HWND hwndOwner, LPCSTR lpszDeviceClass)
 132 {
 133     FIXME("(%08x, %p, %s): stub.\n", dwDeviceID, hwndOwner, lpszDeviceClass);
 134     return 0;
 135 }
 136
 137 /***********************************************************************
 138  *              lineConfigDialogW (TAPI32.@)
 139  */
 140 DWORD WINAPI lineConfigDialogW(DWORD dwDeviceID, HWND hwndOwner, LPCWSTR lpszDeviceClass)
 141 {
 142     FIXME("(%08x, %p, %s): stub.\n", dwDeviceID, hwndOwner, debugstr_w(lpszDeviceClass));
 143     return 0;
 144 }
 145
 146 /***********************************************************************
 147  *              lineConfigDialogEdit (TAPI32.@)
 148  */
 149 DWORD WINAPI lineConfigDialogEditA(DWORD dwDeviceID, HWND hwndOwner, LPCSTR lpszDeviceClass, LPVOID const lpDeviceConfigIn, DWORD dwSize, LPVARSTRING lpDeviceConfigOut)
 150 {
 151     FIXME("stub.\n");
 152     return 0;
 153 }
 154
 155 /***********************************************************************
 156  *              lineConfigProvider (TAPI32.@)
 157  */
 158 DWORD WINAPI lineConfigProvider(HWND hwndOwner, DWORD dwPermanentProviderID)
 159 {
 160     FIXME("(%p, %08x): stub.\n", hwndOwner, dwPermanentProviderID);
 161     return 0;
 162 }
 163
 164 /***********************************************************************
 165  *              lineDeallocateCall (TAPI32.@)
 166  */
 167 DWORD WINAPI lineDeallocateCall(HCALL hCall)
 168 {
 169     FIXME("(%p): stub.\n", hCall);
 170     return 0;
 171 }
 172
 173 /***********************************************************************
 174  *              lineDevSpecific (TAPI32.@)
 175  */
 176 DWORD WINAPI lineDevSpecific(HLINE hLine, DWORD dwAddressId, HCALL hCall, LPVOID lpParams, DWORD dwSize)
 177 {
 178     FIXME("(%p, %08x, %p, %p, %d): stub.\n", hLine, dwAddressId, hCall, lpParams, dwSize);
 179     return 1;
 180 }
 181
 182 /***********************************************************************
 183  *              lineDevSpecificFeature (TAPI32.@)
 184  */
 185 DWORD WINAPI lineDevSpecificFeature(HLINE hLine, DWORD dwFeature, LPVOID lpParams, DWORD dwSize)
 186 {
 187     FIXME("(%p, %08x, %p, %d): stub.\n", hLine, dwFeature, lpParams, dwSize);
 188     return 1;
 189 }
 190
 191 /***********************************************************************
 192  *              lineDial (TAPI32.@)
 193  */
 194 DWORD WINAPI lineDialA(HCALL hCall, LPCSTR lpszDestAddress, DWORD dwCountryCode)
 195 {
 196     FIXME("(%p, %s, %08x): stub.\n", hCall, lpszDestAddress, dwCountryCode);
 197     return 1;
 198 }
 199
 200 /***********************************************************************
 201  *              lineDialW (TAPI32.@)
 202  */
 203 DWORD WINAPI lineDialW(HCALL hCall, LPCWSTR lpszDestAddress, DWORD dwCountryCode)
 204 {
 205     FIXME("(%p, %s, %08x): stub.\n", hCall, debugstr_w(lpszDestAddress), dwCountryCode);
 206     return 1;
 207 }
 208
 209 /***********************************************************************
 210  *              lineDrop (TAPI32.@)
 211  */
 212 DWORD WINAPI lineDrop(HCALL hCall, LPCSTR lpsUserUserInfo, DWORD dwSize)
 213 {
 214     FIXME("(%p, %s, %08x): stub.\n", hCall, lpsUserUserInfo, dwSize);
 215     return 1;
 216 }
 217
 218 /***********************************************************************
 219  *              lineForward (TAPI32.@)
 220  */
 221 DWORD WINAPI lineForwardA(HLINE hLine, DWORD bAllAddress, DWORD dwAddressID, LPLINEFORWARDLIST lpForwardList, DWORD dwNumRingsNoAnswer, LPHCALL lphConsultCall, LPLINECALLPARAMS lpCallParams)
 222 {
 223     FIXME("stub.\n");
 224     return 1;
 225 }
 226
 227 /***********************************************************************
 228  *              lineGatherDigits (TAPI32.@)
 229  */
 230 DWORD WINAPI lineGatherDigitsA(HCALL hCall, DWORD dwDigitModes, LPSTR lpsDigits, DWORD dwNumDigits, LPCSTR lpszTerminationDigits, DWORD dwFirstDigitTimeout, DWORD dwInterDigitTimeout)
 231 {
 232     FIXME("stub.\n");
 233     return 0;
 234 }
 235
 236 /***********************************************************************
 237  *              lineGenerateDigits (TAPI32.@)
 238  */
 239 DWORD WINAPI lineGenerateDigitsA(HCALL hCall, DWORD dwDigitModes, LPCSTR lpszDigits, DWORD dwDuration)
 240 {
 241     FIXME("(%p, %08x, %s, %d): stub.\n", hCall, dwDigitModes, lpszDigits, dwDuration);
 242     return 0;
 243 }
 244
 245 /***********************************************************************
 246  *              lineGenerateTone (TAPI32.@)
 247  */
 248 DWORD WINAPI lineGenerateTone(HCALL hCall, DWORD dwToneMode, DWORD dwDuration, DWORD dwNumTones, LPLINEGENERATETONE lpTones)
 249 {
 250     FIXME("(%p, %08x, %d, %d, %p): stub.\n", hCall, dwToneMode, dwDuration, dwNumTones, lpTones);
 251     return 0;
 252 }
 253
 254 /***********************************************************************
 255  *              lineGetAddressCaps (TAPI32.@)
 256  */
 257 DWORD WINAPI lineGetAddressCapsA(HLINEAPP hLineApp, DWORD dwDeviceID, DWORD dwAddressID, DWORD dwAPIVersion, DWORD dwExtVersion, LPLINEADDRESSCAPS lpAddressCaps)
 258 {
 259     FIXME("(%p, %08x, %08x, %08x, %08x, %p): stub.\n", hLineApp, dwDeviceID, dwAddressID, dwAPIVersion, dwExtVersion, lpAddressCaps);
 260     return 0;
 261 }
 262
 263 /***********************************************************************
 264  *              lineGetAddressID (TAPI32.@)
 265  */
 266 DWORD WINAPI lineGetAddressIDA(HLINE hLine, LPDWORD lpdwAddressID, DWORD dwAddressMode, LPCSTR lpsAddress, DWORD dwSize)
 267 {
 268     FIXME("%p, %p, %08x, %s, %d): stub.\n", hLine, lpdwAddressID, dwAddressMode, lpsAddress, dwSize);
 269     return 0;
 270 }
 271
 272 /***********************************************************************
 273  *              lineGetAddressStatus (TAPI32.@)
 274  */
 275 DWORD WINAPI lineGetAddressStatusA(HLINE hLine, DWORD dwAddressID, LPLINEADDRESSSTATUS lpAddressStatus)
 276 {
 277     FIXME("(%p, %08x, %p): stub.\n", hLine, dwAddressID, lpAddressStatus);
 278     return 0;
 279 }
 280
 281 /***********************************************************************
 282  *              lineGetAppPriority (TAPI32.@)
 283  */
 284 DWORD WINAPI lineGetAppPriorityA(LPCSTR lpszAppFilename, DWORD dwMediaMode, LPLINEEXTENSIONID const lpExtensionID, DWORD dwRequestMode, LPVARSTRING lpExtensionName, LPDWORD lpdwPriority)
 285 {
 286     FIXME("(%s, %08x, %p, %08x, %p, %p): stub.\n", lpszAppFilename, dwMediaMode, lpExtensionID, dwRequestMode, lpExtensionName, lpdwPriority);
 287     return 0;
 288 }
 289
 290 /***********************************************************************
 291  *              lineGetCallInfo (TAPI32.@)
 292  */
 293 DWORD WINAPI lineGetCallInfoA(HCALL hCall, LPLINECALLINFO lpCallInfo)
 294 {
 295     FIXME("(%p, %p): stub.\n", hCall, lpCallInfo);
 296     return 0;
 297 }
 298
 299 /***********************************************************************
 300  *              lineGetCallStatus (TAPI32.@)
 301  */
 302 DWORD WINAPI lineGetCallStatus(HCALL hCall, LPLINECALLSTATUS lpCallStatus)
 303 {
 304     FIXME("(%p, %p): stub.\n", hCall, lpCallStatus);
 305     return 0;
 306 }
 307
 308 /***********************************************************************
 309  *              lineGetConfRelatedCalls (TAPI32.@)
 310  */
 311 DWORD WINAPI lineGetConfRelatedCalls(HCALL hCall, LPLINECALLLIST lpCallList)
 312 {
 313     FIXME("(%p, %p): stub.\n", hCall, lpCallList);
 314     return 0;
 315 }
 316
 317 /***********************************************************************
 318  *              lineGetCountryA (TAPI32.@)
 319  */
 320 DWORD WINAPI lineGetCountryA(DWORD dwCountryID, DWORD dwAPIVersion, LPLINECOUNTRYLIST lpLineCountryList)
 321 {
 322     DWORD dwAvailSize, dwOffset, i, num_countries, max_subkey_len;
 323     LPLINECOUNTRYENTRY lpLCE;
 324     HKEY hkey;
 325     char *subkey_name;
 326
 327     if(!lpLineCountryList) {
 328         TRACE("(%08x, %08x, %p): stub. Returning LINEERR_INVALPOINTER\n",
 329               dwCountryID, dwAPIVersion, lpLineCountryList);
 330         return LINEERR_INVALPOINTER;
 331     }
 332
 333     TRACE("(%08x, %08x, %p(%d)): stub.\n",
 334           dwCountryID, dwAPIVersion, lpLineCountryList,
 335           lpLineCountryList->dwTotalSize);
 336
 337     if(RegOpenKeyA(HKEY_LOCAL_MACHINE, szCountrylistKey, &hkey)
 338             != ERROR_SUCCESS)
 339         return LINEERR_INIFILECORRUPT;
 340
 341
 342     dwAvailSize = lpLineCountryList->dwTotalSize;
 343     dwOffset = sizeof (LINECOUNTRYLIST);
 344
 345     if(dwAvailSize<dwOffset)
 346         return LINEERR_STRUCTURETOOSMALL;
 347
 348     memset(lpLineCountryList, 0, dwAvailSize);
 349
 350     lpLineCountryList->dwTotalSize         = dwAvailSize;
 351     lpLineCountryList->dwUsedSize          = dwOffset;
 352     lpLineCountryList->dwNumCountries      = 0;
 353     lpLineCountryList->dwCountryListSize   = 0;
 354     lpLineCountryList->dwCountryListOffset = dwOffset;
 355
 356     lpLCE = (LPLINECOUNTRYENTRY)(&lpLineCountryList[1]);
 357
 358     if(RegQueryInfoKeyA(hkey, NULL, NULL, NULL, &num_countries, &max_subkey_len,
 359                         NULL, NULL, NULL, NULL, NULL, NULL) != ERROR_SUCCESS) {
 360         RegCloseKey(hkey);
 361         return LINEERR_STRUCTURETOOSMALL;
 362     }
 363
 364     if(dwCountryID)
 365         dwOffset = sizeof (LINECOUNTRYENTRY);
 366     else
 367         dwOffset += num_countries * sizeof (LINECOUNTRYENTRY);
 368
 369     max_subkey_len++;
 370     subkey_name = HeapAlloc(GetProcessHeap(), 0, max_subkey_len);
 371     for(i = 0; i < num_countries; i++)
 372     {
 373         DWORD len, size, size_int, size_long, size_name, size_same;
 374         HKEY hsubkey;
 375
 376         if(RegEnumKeyA(hkey, i, subkey_name, max_subkey_len) !=
 377            ERROR_SUCCESS)
 378             continue;
 379
 380         if(dwCountryID && (atoi(subkey_name) != dwCountryID))
 381             continue;
 382
 383         if(RegOpenKeyA(hkey, subkey_name, &hsubkey) != ERROR_SUCCESS)
 384             continue;
 385
 386         RegQueryValueExA(hsubkey, "InternationalRule", NULL, NULL,
 387                          NULL, &size_int);
 388         len  = size_int;
 389
 390         RegQueryValueExA(hsubkey, "LongDistanceRule", NULL, NULL,
 391                          NULL, &size_long);
 392         len += size_long;
 393
 394         RegQueryValueExA(hsubkey, "Name", NULL, NULL,
 395                          NULL, &size_name);
 396         len += size_name;
 397
 398         RegQueryValueExA(hsubkey, "SameAreaRule", NULL, NULL,
 399                          NULL, &size_same);
 400         len += size_same;
 401
 402         if(dwAvailSize < (dwOffset+len))
 403         {
 404             dwOffset += len;
 405             RegCloseKey(hsubkey);
 406             if(dwCountryID)
 407                 break;
 408             continue;
 409         }
 410
 411         lpLineCountryList->dwNumCountries++;
 412         lpLineCountryList->dwCountryListSize += sizeof (LINECOUNTRYENTRY);
 413         lpLineCountryList->dwUsedSize += len + sizeof (LINECOUNTRYENTRY);
 414
 415         if(dwCountryID)
 416             i = 0;
 417
 418         lpLCE[i].dwCountryID = atoi(subkey_name);
 419         size = sizeof(DWORD);
 420         RegQueryValueExA(hsubkey, "CountryCode", NULL, NULL,
 421                          (BYTE*)&lpLCE[i].dwCountryCode, &size);
 422
 423         lpLCE[i].dwNextCountryID = 0;
 424
 425         if(i > 0)
 426             lpLCE[i-1].dwNextCountryID = lpLCE[i].dwCountryID;
 427
 428         /* add country name */
 429         lpLCE[i].dwCountryNameSize = size_name;
 430         lpLCE[i].dwCountryNameOffset = dwOffset;
 431         RegQueryValueExA(hsubkey, "Name", NULL, NULL,
 432                          ((LPBYTE)lpLineCountryList)+dwOffset,
 433                          &size_name);
 434         dwOffset += size_name;
 435
 436         /* add Same Area Rule */
 437         lpLCE[i].dwSameAreaRuleSize = size_same;
 438         lpLCE[i].dwSameAreaRuleOffset = dwOffset;
 439         RegQueryValueExA(hsubkey, "SameAreaRule", NULL, NULL,
 440                          ((LPBYTE)lpLineCountryList)+dwOffset,
 441                          &size_same);
 442         dwOffset += size_same;
 443
 444         /* add Long Distance Rule */
 445         lpLCE[i].dwLongDistanceRuleSize = size_long;
 446         lpLCE[i].dwLongDistanceRuleOffset = dwOffset;
 447         RegQueryValueExA(hsubkey, "LongDistanceRule", NULL, NULL,
 448                          ((LPBYTE)lpLineCountryList)+dwOffset,
 449                          &size_long);
 450         dwOffset += size_long;
 451
 452         /* add Long Distance Rule */
 453         lpLCE[i].dwInternationalRuleSize = size_int;
 454         lpLCE[i].dwInternationalRuleOffset = dwOffset;
 455         RegQueryValueExA(hsubkey, "InternationalRule", NULL, NULL,
 456                          ((LPBYTE)lpLineCountryList)+dwOffset,
 457                          &size_int);
 458         dwOffset += size_int;
 459         RegCloseKey(hsubkey);
 460
 461         TRACE("Added country %s at %p\n", (LPSTR)lpLineCountryList + lpLCE[i].dwCountryNameOffset,
 462               &lpLCE[i]);
 463
 464         if(dwCountryID) break;
 465     }
 466
 467     lpLineCountryList->dwNeededSize = dwOffset;
 468
 469     TRACE("%d available %d required\n", dwAvailSize, dwOffset);
 470
 471     HeapFree(GetProcessHeap(), 0, subkey_name);
 472     RegCloseKey(hkey);
 473
 474     return 0;
 475 }
 476
 477 /***********************************************************************
 478  *              lineGetCountryW (TAPI32.@)
 479  */
 480 DWORD WINAPI lineGetCountryW(DWORD id, DWORD version, LPLINECOUNTRYLIST list)
 481 {
 482     static const WCHAR country_listW[] =
 483         {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
 484          'W','i','n','d','o','w','s','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
 485          'T','e','l','e','p','h','o','n','y','\\','C','o','u','n','t','r','y',' ','L','i','s','t',0};
 486     static const WCHAR international_ruleW[] =
 487         {'I','n','t','e','r','n','a','t','i','o','n','a','l','R','u','l','e',0};
 488     static const WCHAR longdistance_ruleW[] =
 489         {'L','o','n','g','D','i','s','t','a','n','c','e','R','u','l','e',0};
 490     static const WCHAR samearea_ruleW[] =
 491         {'S','a','m','e','A','r','e','a','R','u','l','e',0};
 492     static const WCHAR nameW[] =
 493         {'N','a','m','e',0};
 494     static const WCHAR country_codeW[] =
 495         {'C','o','u','n','t','r','y','C','o','d','e',0};
 496     DWORD total_size, offset, i, num_countries, max_subkey_len;
 497     LINECOUNTRYENTRY *entry;
 498     WCHAR *subkey_name;
 499     HKEY hkey;
 500
 501     if (!list) return LINEERR_INVALPOINTER;
 502     TRACE("(%08x, %08x, %p(%d))\n", id, version, list, list->dwTotalSize);
 503
 504     if (RegOpenKeyW(HKEY_LOCAL_MACHINE, country_listW, &hkey) != ERROR_SUCCESS)
 505         return LINEERR_INIFILECORRUPT;
 506
 507     total_size = list->dwTotalSize;
 508     offset = sizeof(LINECOUNTRYLIST);
 509     if (total_size < offset) return LINEERR_STRUCTURETOOSMALL;
 510
 511     memset(list, 0, total_size);
 512     list->dwTotalSize         = total_size;
 513     list->dwUsedSize          = offset;
 514     list->dwNumCountries      = 0;
 515     list->dwCountryListSize   = 0;
 516     list->dwCountryListOffset = offset;
 517
 518     entry = (LINECOUNTRYENTRY *)(list + 1);
 519
 520     if (RegQueryInfoKeyW(hkey, NULL, NULL, NULL, &num_countries, &max_subkey_len,
 521                          NULL, NULL, NULL, NULL, NULL, NULL) != ERROR_SUCCESS)
 522     {
 523         RegCloseKey(hkey);
 524         return LINEERR_OPERATIONFAILED;
 525     }
 526     if (id) offset = sizeof(LINECOUNTRYENTRY);
 527     else offset += num_countries * sizeof(LINECOUNTRYENTRY);
 528
 529     max_subkey_len++;
 530     if (!(subkey_name = HeapAlloc(GetProcessHeap(), 0, max_subkey_len * sizeof(WCHAR))))
 531     {
 532         RegCloseKey(hkey);
 533         return LINEERR_NOMEM;
 534     }
 535     for (i = 0; i < num_countries; i++)
 536     {
 537         DWORD len, size, size_int, size_long, size_name, size_same;
 538         HKEY hsubkey;
 539
 540         if (RegEnumKeyW(hkey, i, subkey_name, max_subkey_len) != ERROR_SUCCESS) continue;
 541         if (id && (atoiW(subkey_name) != id)) continue;
 542         if (RegOpenKeyW(hkey, subkey_name, &hsubkey) != ERROR_SUCCESS) continue;
 543
 544         RegQueryValueExW(hsubkey, international_ruleW, NULL, NULL, NULL, &size_int);
 545         len = size_int;
 546
 547         RegQueryValueExW(hsubkey, longdistance_ruleW, NULL, NULL, NULL, &size_long);
 548         len += size_long;
 549
 550         RegQueryValueExW(hsubkey, nameW, NULL, NULL, NULL, &size_name);
 551         len += size_name;
 552
 553         RegQueryValueExW(hsubkey, samearea_ruleW, NULL, NULL, NULL, &size_same);
 554         len += size_same;
 555
 556         if (total_size < offset + len)
 557         {
 558             offset += len;
 559             RegCloseKey(hsubkey);
 560             if (id) break;
 561             continue;
 562         }
 563         list->dwNumCountries++;
 564         list->dwCountryListSize += sizeof(LINECOUNTRYENTRY);
 565         list->dwUsedSize += len + sizeof(LINECOUNTRYENTRY);
 566
 567         if (id) i = 0;
 568         entry[i].dwCountryID = atoiW(subkey_name);
 569         size = sizeof(DWORD);
 570         RegQueryValueExW(hsubkey, country_codeW, NULL, NULL, (BYTE *)&entry[i].dwCountryCode, &size);
 571         entry[i].dwNextCountryID = 0;
 572
 573         if (i > 0) entry[i - 1].dwNextCountryID = entry[i].dwCountryID;
 574
 575         /* add country name */
 576         entry[i].dwCountryNameSize = size_name;
 577         entry[i].dwCountryNameOffset = offset;
 578         RegQueryValueExW(hsubkey, nameW, NULL, NULL, (BYTE *)list + offset, &size_name);
 579         offset += size_name;
 580
 581         /* add Same Area Rule */
 582         entry[i].dwSameAreaRuleSize = size_same;
 583         entry[i].dwSameAreaRuleOffset = offset;
 584         RegQueryValueExW(hsubkey, samearea_ruleW, NULL, NULL, (BYTE *)list + offset, &size_same);
 585         offset += size_same;
 586
 587         /* add Long Distance Rule */
 588         entry[i].dwLongDistanceRuleSize = size_long;
 589         entry[i].dwLongDistanceRuleOffset = offset;
 590         RegQueryValueExW(hsubkey, longdistance_ruleW, NULL, NULL, (BYTE *)list + offset, &size_long);
 591         offset += size_long;
 592
 593         /* add Long Distance Rule */
 594         entry[i].dwInternationalRuleSize = size_int;
 595         entry[i].dwInternationalRuleOffset = offset;
 596         RegQueryValueExW(hsubkey, international_ruleW, NULL, NULL, (BYTE *)list + offset, &size_int);
 597         offset += size_int;
 598         RegCloseKey(hsubkey);
 599
 600         TRACE("added country %s at %p\n",
 601               debugstr_w((const WCHAR *)((const char *)list + entry[i].dwCountryNameOffset)), &entry[i]);
 602         if (id) break;
 603     }
 604     list->dwNeededSize = offset;
 605
 606     TRACE("%d available %d required\n", total_size, offset);
 607
 608     HeapFree(GetProcessHeap(), 0, subkey_name);
 609     RegCloseKey(hkey);
 610     return 0;
 611 }
 612
 613 /***********************************************************************
 614  *              lineGetDevCapsW (TAPI32.@)
 615  */
 616 DWORD WINAPI lineGetDevCapsW(HLINEAPP hLineApp, DWORD dwDeviceID, DWORD dwAPIVersion,
 617                              DWORD dwExtVersion, LPLINEDEVCAPS lpLineDevCaps)
 618 {
 619     static int warn_once;
 620
 621     if(!warn_once++)
 622         FIXME("(%p, %08x, %08x, %08x, %p): stub.\n", hLineApp, dwDeviceID, dwAPIVersion,
 623                                                  dwExtVersion, lpLineDevCaps);
 624     return LINEERR_OPERATIONFAILED;
 625 }
 626
 627 /***********************************************************************
 628  *              lineGetDevCapsA (TAPI32.@)
 629  */
 630 DWORD WINAPI lineGetDevCapsA(HLINEAPP hLineApp, DWORD dwDeviceID, DWORD dwAPIVersion,
 631                              DWORD dwExtVersion, LPLINEDEVCAPS lpLineDevCaps)
 632 {
 633     static int warn_once;
 634
 635     if(!warn_once++)
 636         FIXME("(%p, %08x, %08x, %08x, %p): stub.\n", hLineApp, dwDeviceID, dwAPIVersion,
 637                                                  dwExtVersion, lpLineDevCaps);
 638     return LINEERR_OPERATIONFAILED;
 639 }
 640
 641 /***********************************************************************
 642  *              lineGetDevConfig (TAPI32.@)
 643  */
 644 DWORD WINAPI lineGetDevConfigA(DWORD dwDeviceID, LPVARSTRING lpDeviceConfig, LPCSTR lpszDeviceClass)
 645 {
 646     FIXME("(%08x, %p, %s): stub.\n", dwDeviceID, lpDeviceConfig, lpszDeviceClass);
 647     return 0;
 648 }
 649
 650 /***********************************************************************
 651  *              lineGetIDW (TAPI32.@)
 652  */
 653 DWORD WINAPI lineGetIDW(HLINE hLine, DWORD dwAddressID, HCALL hCall, DWORD dwSelect,
 654                         LPVARSTRING lpDeviceID, LPCWSTR lpszDeviceClass)
 655 {
 656     FIXME("(%p, %08x, %p, %08x, %p, %s): stub.\n", hLine, dwAddressID, hCall,
 657                                                    dwSelect, lpDeviceID,
 658                                                    debugstr_w(lpszDeviceClass));
 659     return LINEERR_OPERATIONFAILED;
 660 }
 661
 662 /***********************************************************************
 663  *              lineGetIDA (TAPI32.@)
 664  */
 665 DWORD WINAPI lineGetIDA(HLINE hLine, DWORD dwAddressID, HCALL hCall, DWORD dwSelect,
 666                         LPVARSTRING lpDeviceID, LPCSTR lpszDeviceClass)
 667 {
 668     FIXME("(%p, %08x, %p, %08x, %p, %s): stub.\n", hLine, dwAddressID, hCall,
 669                                                    dwSelect, lpDeviceID, lpszDeviceClass);
 670     return LINEERR_OPERATIONFAILED;
 671 }
 672
 673 /***********************************************************************
 674  *              lineGetIcon (TAPI32.@)
 675  */
 676 DWORD WINAPI lineGetIconA(DWORD dwDeviceID, LPCSTR lpszDeviceClass, HICON *lphIcon)
 677 {
 678     FIXME("(%08x, %s, %p): stub.\n", dwDeviceID, lpszDeviceClass, lphIcon);
 679     return 0;
 680 }
 681
 682 /***********************************************************************
 683  *              lineGetLineDevStatus (TAPI32.@)
 684  */
 685 DWORD WINAPI lineGetLineDevStatusA(HLINE hLine, LPLINEDEVSTATUS lpLineDevStatus)
 686 {
 687     FIXME("(%p, %p): stub.\n", hLine, lpLineDevStatus);
 688     return 0;
 689 }
 690
 691 /***********************************************************************
 692  *              lineGetMessage (TAPI32.@)
 693  */
 694 DWORD WINAPI lineGetMessage(HLINEAPP hLineApp, LPLINEMESSAGE lpMessage, DWORD dwTimeout)
 695 {
 696     FIXME("(%p, %p, %08x): stub.\n", hLineApp, lpMessage, dwTimeout);
 697     return 0;
 698 }
 699
 700 /***********************************************************************
 701  *              lineGetNewCalls (TAPI32.@)
 702  */
 703 DWORD WINAPI lineGetNewCalls(HLINE hLine, DWORD dwAddressID, DWORD dwSelect, LPLINECALLLIST lpCallList)
 704 {
 705     FIXME("(%p, %08x, %08x, %p): stub.\n", hLine, dwAddressID, dwSelect, lpCallList);
 706     return 0;
 707 }
 708
 709 /***********************************************************************
 710  *              lineGetNumRings (TAPI32.@)
 711  */
 712 DWORD WINAPI lineGetNumRings(HLINE hLine, DWORD dwAddressID, LPDWORD lpdwNumRings)
 713 {
 714     FIXME("(%p, %08x, %p): stub.\n", hLine, dwAddressID, lpdwNumRings);
 715     return 0;
 716 }
 717
 718 /***********************************************************************
 719  *              lineGetProviderListA (TAPI32.@)
 720  */
 721 DWORD WINAPI lineGetProviderListA(DWORD dwAPIVersion, LPLINEPROVIDERLIST lpProviderList)
 722 {
 723     FIXME("(%08x, %p): stub.\n", dwAPIVersion, lpProviderList);
 724     return LINEERR_OPERATIONFAILED;
 725 }
 726
 727 /***********************************************************************
 728  *              lineGetProviderListW (TAPI32.@)
 729  */
 730 DWORD WINAPI lineGetProviderListW(DWORD dwAPIVersion, LPLINEPROVIDERLIST lpProviderList)
 731 {
 732     FIXME("(%08x, %p): stub.\n", dwAPIVersion, lpProviderList);
 733     return LINEERR_OPERATIONFAILED;
 734 }
 735
 736 /***********************************************************************
 737  *              lineGetRequest (TAPI32.@)
 738  */
 739 DWORD WINAPI lineGetRequestA(HLINEAPP hLineApp, DWORD dwRequestMode, LPVOID lpRequestBuffer)
 740 {
 741     FIXME("%p, %08x, %p): stub.\n", hLineApp, dwRequestMode, lpRequestBuffer);
 742     return 0;
 743 }
 744
 745 /***********************************************************************
 746  *              lineGetStatusMessages (TAPI32.@)
 747  */
 748 DWORD WINAPI lineGetStatusMessages(HLINE hLine, LPDWORD lpdwLineStatus, LPDWORD lpdwAddressStates)
 749 {
 750     FIXME("(%p, %p, %p): stub.\n", hLine, lpdwLineStatus, lpdwAddressStates);
 751     return 0;
 752 }
 753
 754 /***********************************************************************
 755  *              lineGetTranslateCaps (TAPI32.@)
 756  *
 757  *      get address translate capabilities. Returns a LINETRANSLATECAPS
 758  *      structure:
 759  *
 760  *      +-----------------------+
 761  *      |TotalSize              |
 762  *      |NeededSize             |
 763  *      |UsedSize               |
 764  *      +-----------------------+
 765  *      |NumLocations           |
 766  *      |LocationsListSize      |
 767  *      |LocationsListOffset    | -+
 768  *      |CurrentLocationID      |  |
 769  *      +-----------------------+  |
 770  *      |NumCards               |  |
 771  *      |CardListSize           |  |
 772  *      |CardListOffset         | -|--+
 773  *      |CurrentPreferredCardID |  |  |
 774  *      +-----------------------+  |  |
 775  *      |                       | <+  |
 776  *      |LINELOCATIONENTRY #1   |     |
 777  *      |                       |     |
 778  *      +-----------------------+     |
 779  *      ~                       ~     |
 780  *      +-----------------------+     |
 781  *      |                       |     |
 782  *      |LINELOCATIONENTRY      |     |
 783  *      |          #NumLocations|     |
 784  *      +-----------------------+     |
 785  *      |                       | <---+
 786  *      |LINECARDENTRY #1       |
 787  *      |                       |
 788  *      +-----------------------+
 789  *      ~                       ~
 790  *      +-----------------------+
 791  *      |                       |
 792  *      |LINECARDENTRY #NumCards|
 793  *      |                       |
 794  *      +-----------------------+
 795  *      | room for strings named|
 796  *      | in the structures     |
 797  *      | above.                |
 798  *      +-----------------------+
 799  */
 800 DWORD WINAPI lineGetTranslateCapsA(HLINEAPP hLineApp, DWORD dwAPIVersion,
 801         LPLINETRANSLATECAPS lpTranslateCaps)
 802 {
 803     HKEY hkLocations, hkCards, hkCardLocations, hsubkey;
 804     int numlocations, numcards;
 805     DWORD maxlockeylen,
 806         maxcardkeylen;
 807     char *loc_key_name = NULL;
 808     char *card_key_name = NULL;
 809     LPBYTE strptr;
 810     int length;
 811     int i;
 812     DWORD lendword;
 813     DWORD currentid;
 814     LPLINELOCATIONENTRY pLocEntry;
 815     LPLINECARDENTRY pCardEntry;
 816
 817     TRACE("(%p, %08x, %p (tot. size %d)\n", hLineApp, dwAPIVersion,
 818             lpTranslateCaps, lpTranslateCaps->dwTotalSize );
 819     if( lpTranslateCaps->dwTotalSize < sizeof(LINETRANSLATECAPS))
 820         return LINEERR_STRUCTURETOOSMALL;
 821     if( RegCreateKeyA(HKEY_LOCAL_MACHINE, szLocationsKey, &hkLocations)
 822             != ERROR_SUCCESS ) {
 823         ERR("unexpected registry error 1.\n");
 824         return LINEERR_INIFILECORRUPT;
 825     }
 826     lendword = sizeof( DWORD);
 827     if( RegQueryValueExA( hkLocations, "CurrentID", NULL, NULL,
 828                 (LPBYTE) &currentid, &lendword) != ERROR_SUCCESS )
 829         currentid = -1;  /* change this later */
 830     if(RegQueryInfoKeyA(hkLocations, NULL, NULL, NULL, NULL, &maxlockeylen,
 831                         NULL, NULL, NULL, NULL, NULL, NULL) != ERROR_SUCCESS) {
 832         RegCloseKey(hkLocations);
 833         ERR("unexpected registry error 2.\n");
 834         return LINEERR_INIFILECORRUPT;
 835     }
 836     maxlockeylen++;
 837     if( maxlockeylen < 10)
 838         maxlockeylen = 10; /* need this also if there is no key */
 839     loc_key_name = HeapAlloc( GetProcessHeap(), 0, maxlockeylen);
 840     /* first time through: calculate needed space */
 841     length=0;
 842     i=0;
 843     numlocations=0;
 844     while( RegEnumKeyA(hkLocations, i, loc_key_name, maxlockeylen)
 845             == ERROR_SUCCESS){
 846         DWORD size_val;
 847         i++;
 848         if( strncasecmp(loc_key_name, "location", 8)  ||
 849                 (RegOpenKeyA(hkLocations, loc_key_name, &hsubkey)
 850                  != ERROR_SUCCESS))
 851             continue;
 852         numlocations++;
 853         length += sizeof(LINELOCATIONENTRY);
 854         RegQueryValueExA(hsubkey, "Name",NULL,NULL,NULL,&size_val);
 855         length += size_val;
 856         RegQueryValueExA(hsubkey, "AreaCode",NULL,NULL,NULL,&size_val);
 857         length += size_val;
 858         RegQueryValueExA(hsubkey, "OutsideAccess",NULL,NULL,NULL,&size_val);
 859         length += size_val;
 860         RegQueryValueExA(hsubkey, "LongDistanceAccess",NULL,NULL,NULL,&size_val);
 861         length += size_val;
 862         RegQueryValueExA(hsubkey, "DisableCallWaiting",NULL,NULL,NULL,&size_val);
 863         length += size_val;
 864         /* fixme: what about TollPrefixList???? */
 865         RegCloseKey(hsubkey);
 866     }
 867     if(numlocations == 0) {
 868         /* add one location */
 869         if( RegCreateKeyA( hkLocations, "Location1", &hsubkey)
 870                 == ERROR_SUCCESS) {
 871             DWORD dwval;
 872             char buf[10];
 873             numlocations = 1;
 874             length += sizeof(LINELOCATIONENTRY) + 20 ;
 875             RegSetValueExA( hsubkey, "AreaCode", 0, REG_SZ, (const BYTE *)"010", 4);
 876             GetLocaleInfoA( LOCALE_SYSTEM_DEFAULT, LOCALE_ICOUNTRY, buf, 8);
 877             dwval = atoi(buf);
 878             RegSetValueExA( hsubkey, "Country", 0, REG_DWORD, (LPBYTE)&dwval,
 879                     sizeof(DWORD));
 880             RegSetValueExA( hsubkey, "DisableCallWaiting", 0, REG_SZ, (const BYTE *)"", 1);
 881             dwval = 1;
 882             RegSetValueExA( hsubkey, "Flags", 0, REG_DWORD, (LPBYTE)&dwval,
 883                     sizeof(DWORD));
 884             RegSetValueExA( hsubkey, "LongDistanceAccess", 0, REG_SZ, (const BYTE *)"", 1);
 885             RegSetValueExA( hsubkey, "Name", 0, REG_SZ, (const BYTE *)"New Location", 13);
 886             RegSetValueExA( hsubkey, "OutsideAccess", 0, REG_SZ, (const BYTE *)"", 1);
 887             RegCloseKey(hsubkey);
 888             dwval = 1;
 889             RegSetValueExA( hkLocations, "CurrentID", 0, REG_DWORD,
 890                     (LPBYTE)&dwval, sizeof(DWORD));
 891             dwval = 2;
 892             RegSetValueExA( hkLocations, "NextID", 0, REG_DWORD, (LPBYTE)&dwval,
 893                     sizeof(DWORD));
 894         }
 895     }
 896     /* do the card list */
 897     numcards=0;
 898     if( RegCreateKeyA(HKEY_CURRENT_USER, szCardsKey, &hkCards)
 899             == ERROR_SUCCESS ) {
 900         if(RegQueryInfoKeyA(hkCards, NULL, NULL, NULL, NULL, &maxcardkeylen,
 901                 NULL, NULL, NULL, NULL, NULL, NULL) == ERROR_SUCCESS) {
 902             maxcardkeylen++;
 903             if( maxcardkeylen < 6) maxcardkeylen = 6;
 904             card_key_name = HeapAlloc(GetProcessHeap(), 0, maxcardkeylen);
 905             i=0;
 906             while( RegEnumKeyA(hkCards, i, card_key_name, maxcardkeylen) ==
 907                     ERROR_SUCCESS){
 908                 DWORD size_val;
 909                 i++;
 910                 if( strncasecmp(card_key_name, "card", 4)  || ERROR_SUCCESS !=
 911                         (RegOpenKeyA(hkCards, card_key_name, &hsubkey) ))
 912                     continue;
 913                 numcards++;
 914                 length += sizeof(LINECARDENTRY);
 915                 RegQueryValueExA(hsubkey, "Name",NULL,NULL,NULL,&size_val);
 916                 length += size_val;
 917                 RegQueryValueExA(hsubkey, "LocalRule",NULL,NULL,NULL,&size_val);
 918                 length += size_val;
 919                 RegQueryValueExA(hsubkey, "LDRule",NULL,NULL,NULL,&size_val);
 920                 length += size_val;
 921                 RegQueryValueExA(hsubkey, "InternationalRule",NULL,NULL,NULL,
 922                         &size_val);
 923                 length += size_val;
 924                 RegCloseKey(hsubkey);
 925             }
 926         }
 927         /* add one card (direct call) */
 928         if (numcards == 0 &&
 929                 ERROR_SUCCESS == RegCreateKeyA( hkCards, "Card1", &hsubkey)) {
 930             DWORD dwval;
 931             numcards = 1;
 932             length += sizeof(LINECARDENTRY) + 22 ;
 933             RegSetValueExA( hsubkey, "Name", 0, REG_SZ, (const BYTE *)"None (Direct Call)", 19);
 934             dwval = 1;
 935             RegSetValueExA( hsubkey, "Flags", 0, REG_DWORD, (LPBYTE)&dwval,
 936                     sizeof(DWORD));
 937             RegSetValueExA( hsubkey, "InternationalRule", 0, REG_SZ, (const BYTE *)"", 1);
 938             RegSetValueExA( hsubkey, "LDRule", 0, REG_SZ, (const BYTE *)"", 1);
 939             RegSetValueExA( hsubkey, "LocalRule", 0, REG_SZ, (const BYTE *)"", 1);
 940             RegCloseKey(hsubkey);
 941             dwval = 2;
 942             RegSetValueExA( hkCards, "NextID", 0, REG_DWORD, (LPBYTE)&dwval,
 943                     sizeof(DWORD));
 944         }
 945     } else hkCards = 0;  /* should really fail */
 946     /* check if sufficient room is available */
 947     lpTranslateCaps->dwNeededSize =  sizeof(LINETRANSLATECAPS) + length;
 948     if ( lpTranslateCaps->dwNeededSize > lpTranslateCaps->dwTotalSize ) {
 949         RegCloseKey( hkLocations);
 950         if( hkCards) RegCloseKey( hkCards);
 951         HeapFree(GetProcessHeap(), 0, loc_key_name);
 952         HeapFree(GetProcessHeap(), 0, card_key_name);
 953         lpTranslateCaps->dwUsedSize = sizeof(LINETRANSLATECAPS);
 954         TRACE("Insufficient space: total %d needed %d used %d\n",
 955                 lpTranslateCaps->dwTotalSize,
 956                 lpTranslateCaps->dwNeededSize,
 957                 lpTranslateCaps->dwUsedSize);
 958         return  0;
 959     }
 960     /* fill in the LINETRANSLATECAPS structure */
 961     lpTranslateCaps->dwUsedSize = lpTranslateCaps->dwNeededSize;
 962     lpTranslateCaps->dwNumLocations = numlocations;
 963     lpTranslateCaps->dwLocationListSize = sizeof(LINELOCATIONENTRY) *
 964             lpTranslateCaps->dwNumLocations;
 965     lpTranslateCaps->dwLocationListOffset = sizeof(LINETRANSLATECAPS);
 966     lpTranslateCaps->dwCurrentLocationID = currentid;
 967     lpTranslateCaps->dwNumCards = numcards;
 968     lpTranslateCaps->dwCardListSize = sizeof(LINECARDENTRY) *
 969             lpTranslateCaps->dwNumCards;
 970     lpTranslateCaps->dwCardListOffset = lpTranslateCaps->dwLocationListOffset +
 971             lpTranslateCaps->dwLocationListSize;
 972     lpTranslateCaps->dwCurrentPreferredCardID = 0;
 973     /* this is where the strings will be stored */
 974     strptr = ((LPBYTE) lpTranslateCaps) +
 975         lpTranslateCaps->dwCardListOffset + lpTranslateCaps->dwCardListSize;
 976     pLocEntry = (LPLINELOCATIONENTRY) (lpTranslateCaps + 1);
 977     /* key with Preferred CardIDs */
 978     if( RegOpenKeyA(HKEY_CURRENT_USER, szLocationsKey, &hkCardLocations)
 979             != ERROR_SUCCESS )
 980         hkCardLocations = 0;
 981     /* second time through all locations */
 982     i=0;
 983     while(RegEnumKeyA(hkLocations, i, loc_key_name, maxlockeylen)
 984             == ERROR_SUCCESS){
 985         DWORD size_val;
 986         i++;
 987         if( strncasecmp(loc_key_name, "location", 8)  ||
 988                 (RegOpenKeyA(hkLocations, loc_key_name, &hsubkey)
 989                  != ERROR_SUCCESS))
 990             continue;
 991         size_val=sizeof(DWORD);
 992         if( RegQueryValueExA(hsubkey, "ID",NULL, NULL,
 993                 (LPBYTE) &(pLocEntry->dwPermanentLocationID), &size_val) !=
 994                 ERROR_SUCCESS)
 995             pLocEntry->dwPermanentLocationID = atoi( loc_key_name + 8);
 996         size_val=2048;
 997         RegQueryValueExA(hsubkey, "Name",NULL,NULL, strptr, &size_val);
 998         pLocEntry->dwLocationNameSize = size_val;
 999         pLocEntry->dwLocationNameOffset = strptr - (LPBYTE) lpTranslateCaps;
1000         strptr += size_val;
1001
1002         size_val=2048;
1003         RegQueryValueExA(hsubkey, "AreaCode",NULL,NULL, strptr, &size_val);
1004         pLocEntry->dwCityCodeSize = size_val;
1005         pLocEntry->dwCityCodeOffset = strptr - (LPBYTE) lpTranslateCaps;
1006         strptr += size_val;
1007
1008         size_val=2048;
1009         RegQueryValueExA(hsubkey, "OutsideAccess",NULL,NULL, strptr, &size_val);
1010         pLocEntry->dwLocalAccessCodeSize = size_val;
1011         pLocEntry->dwLocalAccessCodeOffset = strptr - (LPBYTE) lpTranslateCaps;
1012         strptr += size_val;
1013         size_val=2048;
1014         RegQueryValueExA(hsubkey, "LongDistanceAccess",NULL,NULL, strptr,
1015                 &size_val);
1016         pLocEntry->dwLongDistanceAccessCodeSize= size_val;
1017         pLocEntry->dwLongDistanceAccessCodeOffset= strptr -
1018             (LPBYTE) lpTranslateCaps;
1019         strptr += size_val;
1020         size_val=2048;
1021         RegQueryValueExA(hsubkey, "DisableCallWaiting",NULL,NULL, strptr,
1022                 &size_val);
1023         pLocEntry->dwCancelCallWaitingSize= size_val;
1024         pLocEntry->dwCancelCallWaitingOffset= strptr - (LPBYTE) lpTranslateCaps;
1025         strptr += size_val;
1026
1027         pLocEntry->dwTollPrefixListSize = 0;    /* FIXME */
1028         pLocEntry->dwTollPrefixListOffset = 0;    /* FIXME */
1029
1030         size_val=sizeof(DWORD);
1031         RegQueryValueExA(hsubkey, "Country",NULL,NULL,
1032                 (LPBYTE) &(pLocEntry->dwCountryCode), &size_val);
1033         pLocEntry->dwCountryID = pLocEntry->dwCountryCode; /* FIXME */
1034         RegQueryValueExA(hsubkey, "Flags",NULL,NULL,
1035                 (LPBYTE) &(pLocEntry->dwOptions), &size_val);
1036         RegCloseKey(hsubkey);
1037         /* get preferred cardid */
1038         pLocEntry->dwPreferredCardID = 0;
1039         if ( hkCardLocations) {
1040             size_val=sizeof(DWORD);
1041             if(RegOpenKeyA(hkCardLocations, loc_key_name, &hsubkey) ==
1042                     ERROR_SUCCESS) {
1043                 RegQueryValueExA(hsubkey, "CallingCard",NULL,NULL,
1044                         (LPBYTE) &(pLocEntry->dwPreferredCardID), &size_val);
1045                 RegCloseKey(hsubkey);
1046             }
1047
1048         }
1049         /* make sure there is a currentID */
1050         if(currentid == -1){
1051             currentid = pLocEntry->dwPermanentLocationID;
1052             lpTranslateCaps->dwCurrentLocationID = currentid;
1053         }
1054         if(pLocEntry->dwPermanentLocationID == currentid )
1055             lpTranslateCaps->dwCurrentPreferredCardID =
1056                     pLocEntry->dwPreferredCardID;
1057         TRACE("added: ID %d %s CountryCode %d CityCode %s CardID %d "
1058                 "LocalAccess: %s LongDistanceAccess: %s CountryID %d "
1059                 "Options %d CancelCallWait %s\n",
1060                 pLocEntry->dwPermanentLocationID,
1061                 debugstr_a( (char*)lpTranslateCaps + pLocEntry->dwLocationNameOffset),
1062                 pLocEntry->dwCountryCode,
1063                 debugstr_a( (char*)lpTranslateCaps + pLocEntry->dwCityCodeOffset),
1064                 pLocEntry->dwPreferredCardID,
1065                 debugstr_a( (char*)lpTranslateCaps + pLocEntry->dwLocalAccessCodeOffset),
1066                 debugstr_a( (char*)lpTranslateCaps + pLocEntry->dwLongDistanceAccessCodeOffset),
1067                 pLocEntry->dwCountryID,
1068                 pLocEntry->dwOptions,
1069                 debugstr_a( (char*)lpTranslateCaps + pLocEntry->dwCancelCallWaitingOffset));
1070         pLocEntry++;
1071     }
1072     pCardEntry= (LPLINECARDENTRY) pLocEntry;
1073     /* do the card list */
1074     if( hkCards) {
1075         i=0;
1076         while( RegEnumKeyA(hkCards, i, card_key_name, maxcardkeylen) ==
1077                 ERROR_SUCCESS){
1078             DWORD size_val;
1079             i++;
1080             if( strncasecmp(card_key_name, "card", 4)  ||
1081                     (RegOpenKeyA(hkCards, card_key_name, &hsubkey) != ERROR_SUCCESS))
1082                 continue;
1083             size_val=sizeof(DWORD);
1084             if( RegQueryValueExA(hsubkey, "ID",NULL, NULL,
1085                     (LPBYTE) &(pCardEntry->dwPermanentCardID), &size_val) !=
1086                     ERROR_SUCCESS)
1087                 pCardEntry->dwPermanentCardID= atoi( card_key_name + 4);
1088             size_val=2048;
1089             RegQueryValueExA(hsubkey, "Name",NULL,NULL, strptr, &size_val);
1090             pCardEntry->dwCardNameSize = size_val;
1091             pCardEntry->dwCardNameOffset = strptr - (LPBYTE) lpTranslateCaps;
1092             strptr += size_val;
1093             pCardEntry->dwCardNumberDigits = 1; /* FIXME */
1094             size_val=2048;
1095             RegQueryValueExA(hsubkey, "LocalRule",NULL,NULL, strptr, &size_val);
1096             pCardEntry->dwSameAreaRuleSize= size_val;
1097             pCardEntry->dwSameAreaRuleOffset= strptr - (LPBYTE) lpTranslateCaps;
1098             strptr += size_val;
1099             size_val=2048;
1100             RegQueryValueExA(hsubkey, "LDRule",NULL,NULL, strptr, &size_val);
1101             pCardEntry->dwLongDistanceRuleSize = size_val;
1102             pCardEntry->dwLongDistanceRuleOffset = strptr - (LPBYTE) lpTranslateCaps;
1103             strptr += size_val;
1104             size_val=2048;
1105             RegQueryValueExA(hsubkey, "InternationalRule",NULL,NULL, strptr,
1106                     &size_val);
1107             pCardEntry->dwInternationalRuleSize = size_val;
1108             pCardEntry->dwInternationalRuleOffset = strptr -
1109                 (LPBYTE) lpTranslateCaps;
1110             strptr += size_val;
1111             size_val=sizeof(DWORD);
1112             RegQueryValueExA(hsubkey, "Flags",NULL, NULL,
1113                     (LPBYTE) &(pCardEntry->dwOptions), &size_val);
1114             TRACE( "added card: ID %d name %s SameArea %s LongDistance %s International %s Options 0x%x\n",
1115                     pCardEntry->dwPermanentCardID,
1116                     debugstr_a( (char*)lpTranslateCaps + pCardEntry->dwCardNameOffset),
1117                     debugstr_a( (char*)lpTranslateCaps + pCardEntry->dwSameAreaRuleOffset),
1118                     debugstr_a( (char*)lpTranslateCaps + pCardEntry->dwLongDistanceRuleOffset),
1119                     debugstr_a( (char*)lpTranslateCaps + pCardEntry->dwInternationalRuleOffset),
1120                     pCardEntry->dwOptions);
1121
1122             pCardEntry++;
1123         }
1124     }
1125
1126     if(hkLocations) RegCloseKey(hkLocations);
1127     if(hkCards) RegCloseKey(hkCards);
1128     if(hkCardLocations) RegCloseKey(hkCardLocations);
1129     HeapFree(GetProcessHeap(), 0, loc_key_name);
1130     HeapFree(GetProcessHeap(), 0, card_key_name);
1131     TRACE(" returning success tot %d needed %d used %d\n",
1132             lpTranslateCaps->dwTotalSize,
1133             lpTranslateCaps->dwNeededSize,
1134             lpTranslateCaps->dwUsedSize );
1135     return 0; /* success */
1136 }
1137
1138 /***********************************************************************
1139  *              lineHandoff (TAPI32.@)
1140  */
1141 DWORD WINAPI lineHandoffA(HCALL hCall, LPCSTR lpszFileName, DWORD dwMediaMode)
1142 {
1143     FIXME("(%p, %s, %08x): stub.\n", hCall, lpszFileName, dwMediaMode);
1144     return 0;
1145 }
1146
1147 /***********************************************************************
1148  *              lineHold (TAPI32.@)
1149  */
1150 DWORD WINAPI lineHold(HCALL hCall)
1151 {
1152     FIXME("(%p): stub.\n", hCall);
1153     return 1;
1154 }
1155
1156 /***********************************************************************
1157  *              lineInitialize (TAPI32.@)
1158  */
1159 DWORD WINAPI lineInitialize(
1160   LPHLINEAPP lphLineApp,
1161   HINSTANCE hInstance,
1162   LINECALLBACK lpfnCallback,
1163   LPCSTR lpszAppName,
1164   LPDWORD lpdwNumDevs)
1165 {
1166     FIXME("(%p, %p, %p, %s, %p): stub.\n", lphLineApp, hInstance,
1167           lpfnCallback, debugstr_a(lpszAppName), lpdwNumDevs);
1168     return 0;
1169 }
1170
1171 /***********************************************************************
1172  *              lineInitializeExA (TAPI32.@)
1173  */
1174 LONG WINAPI lineInitializeExA(LPHLINEAPP lphLineApp, HINSTANCE hInstance, LINECALLBACK lpfnCallback, LPCSTR lpszFriendlyAppName, LPDWORD lpdwNumDevs, LPDWORD lpdwAPIVersion, LPLINEINITIALIZEEXPARAMS lpLineInitializeExParams)
1175 {
1176     FIXME("(%p, %p, %p, %s, %p, %p, %p): stub.\n", lphLineApp, hInstance,
1177           lpfnCallback, debugstr_a(lpszFriendlyAppName), lpdwNumDevs, lpdwAPIVersion, lpLineInitializeExParams);
1178     return 0;
1179 }
1180
1181 /***********************************************************************
1182  *              lineInitializeExW (TAPI32.@)
1183  */
1184 LONG WINAPI lineInitializeExW(LPHLINEAPP lphLineApp, HINSTANCE hInstance, LINECALLBACK lpfnCallback, LPCWSTR lpszFriendlyAppName, LPDWORD lpdwNumDevs, LPDWORD lpdwAPIVersion, LPLINEINITIALIZEEXPARAMS lpLineInitializeExParams)
1185 {
1186     FIXME("(%p, %p, %p, %s, %p, %p, %p): stub.\n", lphLineApp, hInstance,
1187           lpfnCallback, debugstr_w(lpszFriendlyAppName), lpdwNumDevs, lpdwAPIVersion, lpLineInitializeExParams);
1188     return 0;
1189 }
1190
1191 /***********************************************************************
1192  *              lineMakeCallW (TAPI32.@)
1193  */
1194 DWORD WINAPI lineMakeCallW(HLINE hLine, LPHCALL lphCall, LPCWSTR lpszDestAddress,
1195                            DWORD dwCountryCode, LPLINECALLPARAMS lpCallParams)
1196 {
1197     FIXME("(%p, %p, %s, %08x, %p): stub.\n", hLine, lphCall, debugstr_w(lpszDestAddress),
1198                                              dwCountryCode, lpCallParams);
1199     return LINEERR_OPERATIONFAILED;
1200 }
1201
1202 /***********************************************************************
1203  *              lineMakeCallA (TAPI32.@)
1204  */
1205 DWORD WINAPI lineMakeCallA(HLINE hLine, LPHCALL lphCall, LPCSTR lpszDestAddress,
1206                            DWORD dwCountryCode, LPLINECALLPARAMS lpCallParams)
1207 {
1208     FIXME("(%p, %p, %s, %08x, %p): stub.\n", hLine, lphCall, lpszDestAddress,
1209                                              dwCountryCode, lpCallParams);
1210     return LINEERR_OPERATIONFAILED;
1211 }
1212
1213 /***********************************************************************
1214  *              lineMonitorDigits (TAPI32.@)
1215  */
1216 DWORD WINAPI lineMonitorDigits(HCALL hCall, DWORD dwDigitModes)
1217 {
1218     FIXME("(%p, %08x): stub.\n", hCall, dwDigitModes);
1219     return 0;
1220 }
1221
1222 /***********************************************************************
1223  *              lineMonitorMedia (TAPI32.@)
1224  */
1225 DWORD WINAPI lineMonitorMedia(HCALL hCall, DWORD dwMediaModes)
1226 {
1227     FIXME("(%p, %08x): stub.\n", hCall, dwMediaModes);
1228     return 0;
1229 }
1230
1231 /***********************************************************************
1232  *              lineMonitorTones (TAPI32.@)
1233  */
1234 DWORD WINAPI lineMonitorTones(HCALL hCall, LPLINEMONITORTONE lpToneList, DWORD dwNumEntries)
1235 {
1236     FIXME("(%p, %p, %08x): stub.\n", hCall, lpToneList, dwNumEntries);
1237     return 0;
1238 }
1239
1240 /***********************************************************************
1241  *              lineNegotiateAPIVersion (TAPI32.@)
1242  */
1243 DWORD WINAPI lineNegotiateAPIVersion(
1244   HLINEAPP hLineApp,
1245   DWORD dwDeviceID,
1246   DWORD dwAPILowVersion,
1247   DWORD dwAPIHighVersion,
1248   LPDWORD lpdwAPIVersion,
1249   LPLINEEXTENSIONID lpExtensionID
1250 )
1251 {
1252     static int warn_once;
1253
1254     if(!warn_once++)
1255         FIXME("(%p, %d, %d, %d, %p, %p): stub.\n", hLineApp, dwDeviceID,
1256               dwAPILowVersion, dwAPIHighVersion, lpdwAPIVersion, lpExtensionID);
1257     *lpdwAPIVersion = dwAPIHighVersion;
1258     return 0;
1259 }
1260
1261 /***********************************************************************
1262  *              lineNegotiateExtVersion (TAPI32.@)
1263  */
1264 DWORD WINAPI lineNegotiateExtVersion(HLINEAPP hLineApp, DWORD dwDeviceID, DWORD dwAPIVersion, DWORD dwExtLowVersion, DWORD dwExtHighVersion, LPDWORD lpdwExtVersion)
1265 {
1266     FIXME("stub.\n");
1267     return 0;
1268 }
1269
1270 /***********************************************************************
1271  *              lineOpenW (TAPI32.@)
1272  */
1273 DWORD WINAPI lineOpenW(HLINEAPP hLineApp, DWORD dwDeviceID, LPHLINE lphLine, DWORD dwAPIVersion, DWORD dwExtVersion, DWORD dwCallbackInstance, DWORD dwPrivileges, DWORD dwMediaModes, LPLINECALLPARAMS lpCallParams)
1274 {
1275     FIXME("stub.\n");
1276     return 0;
1277 }
1278
1279 /***********************************************************************
1280  *              lineOpen (TAPI32.@)
1281  */
1282 DWORD WINAPI lineOpenA(HLINEAPP hLineApp, DWORD dwDeviceID, LPHLINE lphLine, DWORD dwAPIVersion, DWORD dwExtVersion, DWORD dwCallbackInstance, DWORD dwPrivileges, DWORD dwMediaModes, LPLINECALLPARAMS lpCallParams)
1283 {
1284     FIXME("stub.\n");
1285     return 0;
1286 }
1287
1288 /***********************************************************************
1289  *              linePark (TAPI32.@)
1290  */
1291 DWORD WINAPI lineParkA(HCALL hCall, DWORD dwParkMode, LPCSTR lpszDirAddress, LPVARSTRING lpNonDirAddress)
1292 {
1293     FIXME("(%p, %08x, %s, %p): stub.\n", hCall, dwParkMode, lpszDirAddress, lpNonDirAddress);
1294     return 1;
1295 }
1296
1297 /***********************************************************************
1298  *              linePickup (TAPI32.@)
1299  */
1300 DWORD WINAPI linePickupA(HLINE hLine, DWORD dwAddressID, LPHCALL lphCall, LPCSTR lpszDestAddress, LPCSTR lpszGroupID)
1301 {
1302     FIXME("(%p, %08x, %p, %s, %s): stub.\n", hLine, dwAddressID, lphCall, lpszDestAddress, lpszGroupID);
1303     return 1;
1304 }
1305
1306 /***********************************************************************
1307  *              linePrepareAddToConference (TAPI32.@)
1308  */
1309 DWORD WINAPI linePrepareAddToConferenceA(HCALL hConfCall, LPHCALL lphConsultCall, LPLINECALLPARAMS lpCallParams)
1310 {
1311     FIXME("(%p, %p, %p): stub.\n", hConfCall, lphConsultCall, lpCallParams);
1312     return 1;
1313 }
1314
1315 /***********************************************************************
1316  *              lineRedirect (TAPI32.@)
1317  */
1318 DWORD WINAPI lineRedirectA(
1319   HCALL hCall,
1320   LPCSTR lpszDestAddress,
1321   DWORD  dwCountryCode) {
1322
1323   FIXME(": stub.\n");
1324   return 1;
1325 }
1326
1327 /***********************************************************************
1328  *              lineRegisterRequestRecipient (TAPI32.@)
1329  */
1330 DWORD WINAPI lineRegisterRequestRecipient(HLINEAPP hLineApp, DWORD dwRegistrationInstance, DWORD dwRequestMode, DWORD dwEnable)
1331 {
1332     FIXME("(%p, %08x, %08x, %08x): stub.\n", hLineApp, dwRegistrationInstance, dwRequestMode, dwEnable);
1333     return 1;
1334 }
1335
1336 /***********************************************************************
1337  *              lineReleaseUserUserInfo (TAPI32.@)
1338  */
1339 DWORD WINAPI lineReleaseUserUserInfo(HCALL hCall)
1340 {
1341     FIXME("(%p): stub.\n", hCall);
1342     return 1;
1343 }
1344
1345 /***********************************************************************
1346  *              lineRemoveFromConference (TAPI32.@)
1347  */
1348 DWORD WINAPI lineRemoveFromConference(HCALL hCall)
1349 {
1350     FIXME("(%p): stub.\n", hCall);
1351     return 1;
1352 }
1353
1354 /***********************************************************************
1355  *              lineRemoveProvider (TAPI32.@)
1356  */
1357 DWORD WINAPI lineRemoveProvider(DWORD dwPermanentProviderID, HWND hwndOwner)
1358 {
1359     FIXME("(%08x, %p): stub.\n", dwPermanentProviderID, hwndOwner);
1360     return 1;
1361 }
1362
1363 /***********************************************************************
1364  *              lineSecureCall (TAPI32.@)
1365  */
1366 DWORD WINAPI lineSecureCall(HCALL hCall)
1367 {
1368     FIXME("(%p): stub.\n", hCall);
1369     return 1;
1370 }
1371
1372 /***********************************************************************
1373  *              lineSendUserUserInfo (TAPI32.@)
1374  */
1375 DWORD WINAPI lineSendUserUserInfo(HCALL hCall, LPCSTR lpsUserUserInfo, DWORD dwSize)
1376 {
1377     FIXME("(%p, %s, %08x): stub.\n", hCall, lpsUserUserInfo, dwSize);
1378     return 1;
1379 }
1380
1381 /***********************************************************************
1382  *              lineSetAppPriority (TAPI32.@)
1383  */
1384 DWORD WINAPI lineSetAppPriorityA(LPCSTR lpszAppFilename, DWORD dwMediaMode, LPLINEEXTENSIONID const lpExtensionID, DWORD dwRequestMode, LPCSTR lpszExtensionName, DWORD dwPriority)
1385 {
1386     FIXME("(%s, %08x, %p, %08x, %s, %08x): stub.\n", lpszAppFilename, dwMediaMode, lpExtensionID, dwRequestMode, lpszExtensionName, dwPriority);
1387     return 0;
1388 }
1389
1390 /***********************************************************************
1391  *              lineSetAppSpecific (TAPI32.@)
1392  */
1393 DWORD WINAPI lineSetAppSpecific(HCALL hCall, DWORD dwAppSpecific)
1394 {
1395     FIXME("(%p, %08x): stub.\n", hCall, dwAppSpecific);
1396     return 0;
1397 }
1398
1399 /***********************************************************************
1400  *              lineSetCallParams (TAPI32.@)
1401  */
1402 DWORD WINAPI lineSetCallParams(HCALL hCall, DWORD dwBearerMode, DWORD dwMinRate, DWORD dwMaxRate, LPLINEDIALPARAMS lpDialParams)
1403 {
1404     FIXME("(%p, %08x, %08x, %08x, %p): stub.\n", hCall, dwBearerMode, dwMinRate, dwMaxRate, lpDialParams);
1405     return 1;
1406 }
1407
1408 /***********************************************************************
1409  *              lineSetCallPrivilege (TAPI32.@)
1410  */
1411 DWORD WINAPI lineSetCallPrivilege(HCALL hCall, DWORD dwCallPrivilege)
1412 {
1413     FIXME("(%p, %08x): stub.\n", hCall, dwCallPrivilege);
1414     return 0;
1415 }
1416
1417 /***********************************************************************
1418  *              lineSetCurrentLocation (TAPI32.@)
1419  */
1420 DWORD WINAPI lineSetCurrentLocation(HLINEAPP hLineApp, DWORD dwLocation)
1421 {
1422     FIXME("(%p, %08x): stub.\n", hLineApp, dwLocation);
1423     return 0;
1424 }
1425
1426 /***********************************************************************
1427  *              lineSetDevConfig (TAPI32.@)
1428  */
1429 DWORD WINAPI lineSetDevConfigA(DWORD dwDeviceID, LPVOID lpDeviceConfig, DWORD dwSize, LPCSTR lpszDeviceClass)
1430 {
1431     FIXME("(%08x, %p, %08x, %s): stub.\n", dwDeviceID, lpDeviceConfig, dwSize, lpszDeviceClass);
1432     return 0;
1433 }
1434
1435 /***********************************************************************
1436  *              lineSetMediaControl (TAPI32.@)
1437  */
1438 DWORD WINAPI lineSetMediaControl(
1439 HLINE hLine,
1440 DWORD dwAddressID,
1441 HCALL hCall,
1442 DWORD dwSelect,
1443 LPLINEMEDIACONTROLDIGIT const lpDigitList,
1444 DWORD dwDigitNumEntries,
1445 LPLINEMEDIACONTROLMEDIA const lpMediaList,
1446 DWORD dwMediaNumEntries,
1447 LPLINEMEDIACONTROLTONE const lpToneList,
1448 DWORD dwToneNumEntries,
1449 LPLINEMEDIACONTROLCALLSTATE const lpCallStateList,
1450 DWORD dwCallStateNumEntries)
1451 {
1452     FIXME(": stub.\n");
1453     return 0;
1454 }
1455
1456 /***********************************************************************
1457  *              lineSetMediaMode (TAPI32.@)
1458  */
1459 DWORD WINAPI lineSetMediaMode(HCALL hCall, DWORD dwMediaModes)
1460 {
1461     FIXME("(%p, %08x): stub.\n", hCall, dwMediaModes);
1462     return 0;
1463 }
1464
1465 /***********************************************************************
1466  *              lineSetNumRings (TAPI32.@)
1467  */
1468 DWORD WINAPI lineSetNumRings(HLINE hLine, DWORD dwAddressID, DWORD dwNumRings)
1469 {
1470     FIXME("(%p, %08x, %08x): stub.\n", hLine, dwAddressID, dwNumRings);
1471     return 0;
1472 }
1473
1474 /***********************************************************************
1475  *              lineSetStatusMessages (TAPI32.@)
1476  */
1477 DWORD WINAPI lineSetStatusMessages(HLINE hLine, DWORD dwLineStates, DWORD dwAddressStates)
1478 {
1479     FIXME("(%p, %08x, %08x): stub.\n", hLine, dwLineStates, dwAddressStates);
1480     return 0;
1481 }
1482
1483 /***********************************************************************
1484  *              lineSetTerminal (TAPI32.@)
1485  */
1486 DWORD WINAPI lineSetTerminal(HLINE hLine, DWORD dwAddressID, HCALL hCall, DWORD dwSelect, DWORD dwTerminalModes, DWORD dwTerminalID, DWORD bEnable)
1487 {
1488     FIXME("(%p, %08x, %p, %08x, %08x, %08x, %08x): stub.\n", hLine, dwAddressID, hCall, dwSelect, dwTerminalModes, dwTerminalID, bEnable);
1489     return 1;
1490 }
1491
1492 /***********************************************************************
1493  *              lineSetTollList (TAPI32.@)
1494  */
1495 DWORD WINAPI lineSetTollListA(HLINEAPP hLineApp, DWORD dwDeviceID, LPCSTR lpszAddressIn, DWORD dwTollListOption)
1496 {
1497     FIXME("(%p, %08x, %s, %08x): stub.\n", hLineApp, dwDeviceID, lpszAddressIn, dwTollListOption);
1498     return 0;
1499 }
1500
1501 /***********************************************************************
1502  *              lineSetupConference (TAPI32.@)
1503  */
1504 DWORD WINAPI lineSetupConferenceA(HCALL hCall, HLINE hLine, LPHCALL lphConfCall, LPHCALL lphConsultCall, DWORD dwNumParties, LPLINECALLPARAMS lpCallParams)
1505 {
1506     FIXME("(%p, %p, %p, %p, %08x, %p): stub.\n", hCall, hLine, lphConfCall, lphConsultCall, dwNumParties, lpCallParams);
1507     return 1;
1508 }
1509
1510 /***********************************************************************
1511  *              lineSetupTransfer (TAPI32.@)
1512  */
1513 DWORD WINAPI lineSetupTransferA(HCALL hCall, LPHCALL lphConsultCall, LPLINECALLPARAMS lpCallParams)
1514 {
1515     FIXME("(%p, %p, %p): stub.\n", hCall, lphConsultCall, lpCallParams);
1516     return 1;
1517 }
1518
1519 /***********************************************************************
1520  *              lineShutdown (TAPI32.@)
1521  */
1522 DWORD WINAPI lineShutdown(HLINEAPP hLineApp)
1523 {
1524     FIXME("(%p): stub.\n", hLineApp);
1525     return 0;
1526 }
1527
1528 /***********************************************************************
1529  *              lineSwapHold (TAPI32.@)
1530  */
1531 DWORD WINAPI lineSwapHold(HCALL hActiveCall, HCALL hHeldCall)
1532 {
1533     FIXME("(active: %p, held: %p): stub.\n", hActiveCall, hHeldCall);
1534     return 1;
1535 }
1536
1537 /***********************************************************************
1538  *              lineTranslateAddress (TAPI32.@)
1539  */
1540 DWORD WINAPI lineTranslateAddressA(HLINEAPP hLineApp, DWORD dwDeviceID, DWORD dwAPIVersion, LPCSTR lpszAddressIn, DWORD dwCard, DWORD dwTranslateOptions, LPLINETRANSLATEOUTPUT lpTranslateOutput)
1541 {
1542     FIXME("(%p, %08x, %08x, %s, %08x, %08x, %p): stub.\n", hLineApp, dwDeviceID, dwAPIVersion, lpszAddressIn, dwCard, dwTranslateOptions, lpTranslateOutput);
1543     return 0;
1544 }
1545
1546 /***********************************************************************
1547  *              lineTranslateAddressW (TAPI32.@)
1548  */
1549 DWORD WINAPI lineTranslateAddressW(HLINEAPP hLineApp, DWORD dwDeviceID,
1550         DWORD dwAPIVersion, LPCWSTR lpszAddressIn, DWORD dwCard,
1551         DWORD dwTranslateOptions, LPLINETRANSLATEOUTPUT lpTranslateOutput)
1552 {
1553     FIXME("(%p, %08x, %08x, %s, %08x, %08x, %p): stub.\n", hLineApp, dwDeviceID, dwAPIVersion,
1554             debugstr_w(lpszAddressIn), dwCard, dwTranslateOptions, lpTranslateOutput);
1555     return 0;
1556 }
1557
1558 /***********************************************************************
1559  *              lineTranslateDialog (TAPI32.@)
1560  */
1561 DWORD WINAPI lineTranslateDialogA(HLINEAPP hLineApp, DWORD dwDeviceID, DWORD dwAPIVersion, HWND hwndOwner, LPCSTR lpszAddressIn)
1562 {
1563     FIXME("(%p, %08x, %08x, %p, %s): stub.\n", hLineApp, dwDeviceID, dwAPIVersion, hwndOwner, lpszAddressIn);
1564     return 0;
1565 }
1566
1567 /***********************************************************************
1568  *              lineTranslateDialogW (TAPI32.@)
1569  */
1570 DWORD WINAPI lineTranslateDialogW(HLINEAPP hLineApp, DWORD dwDeviceID,
1571         DWORD dwAPIVersion, HWND hwndOwner, LPCWSTR lpszAddressIn)
1572 {
1573     FIXME("(%p, %08x, %08x, %p, %s): stub.\n", hLineApp, dwDeviceID,
1574             dwAPIVersion, hwndOwner, debugstr_w(lpszAddressIn));
1575     return 0;
1576 }
1577
1578 /***********************************************************************
1579  *              lineUncompleteCall (TAPI32.@)
1580  */
1581 DWORD WINAPI lineUncompleteCall(HLINE hLine, DWORD dwCompletionID)
1582 {
1583     FIXME("(%p, %08x): stub.\n", hLine, dwCompletionID);
1584     return 1;
1585 }
1586
1587 /***********************************************************************
1588  *              lineUnhold (TAPI32.@)
1589  */
1590 DWORD WINAPI lineUnhold(HCALL hCall)
1591 {
1592     FIXME("(%p): stub.\n", hCall);
1593     return 1;
1594 }
1595
1596 /***********************************************************************
1597  *              lineUnpark (TAPI32.@)
1598  */
1599 DWORD WINAPI lineUnparkA(HLINE hLine, DWORD dwAddressID, LPHCALL lphCall, LPCSTR lpszDestAddress)
1600 {
1601     FIXME("(%p, %08x, %p, %s): stub.\n", hLine, dwAddressID, lphCall, lpszDestAddress);
1602     return 1;
1603 }