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