dlls/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 "winternl.h"
  28 #include "wingdi.h"
  29 #include "winreg.h"
  30 #include "winnls.h"
  31 #include "winerror.h"
  32 #include "objbase.h"
  33 #include "tapi.h"
  34 #include "wine/debug.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 && (wcstol(subkey_name, NULL, 10) != 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 = wcstol(subkey_name, NULL, 10);
 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  *              lineGetTranslateCapsW (TAPI32.@)
 756  */
 757 DWORD WINAPI lineGetTranslateCapsW(HLINEAPP line_app, DWORD api_version, LINETRANSLATECAPS *caps)
 758 {
 759     FIXME("(%p, %08x, %p): stub.\n", line_app, api_version, caps);
 760     return LINEERR_OPERATIONFAILED;
 761 }
 762
 763 /***********************************************************************
 764  *              lineGetTranslateCaps (TAPI32.@)
 765  *
 766  *      get address translate capabilities. Returns a LINETRANSLATECAPS
 767  *      structure:
 768  *
 769  *      +-----------------------+
 770  *      |TotalSize              |
 771  *      |NeededSize             |
 772  *      |UsedSize               |
 773  *      +-----------------------+
 774  *      |NumLocations           |
 775  *      |LocationsListSize      |
 776  *      |LocationsListOffset    | -+
 777  *      |CurrentLocationID      |  |
 778  *      +-----------------------+  |
 779  *      |NumCards               |  |
 780  *      |CardListSize           |  |
 781  *      |CardListOffset         | -|--+
 782  *      |CurrentPreferredCardID |  |  |
 783  *      +-----------------------+  |  |
 784  *      |                       | <+  |
 785  *      |LINELOCATIONENTRY #1   |     |
 786  *      |                       |     |
 787  *      +-----------------------+     |
 788  *      ~                       ~     |
 789  *      +-----------------------+     |
 790  *      |                       |     |
 791  *      |LINELOCATIONENTRY      |     |
 792  *      |          #NumLocations|     |
 793  *      +-----------------------+     |
 794  *      |                       | <---+
 795  *      |LINECARDENTRY #1       |
 796  *      |                       |
 797  *      +-----------------------+
 798  *      ~                       ~
 799  *      +-----------------------+
 800  *      |                       |
 801  *      |LINECARDENTRY #NumCards|
 802  *      |                       |
 803  *      +-----------------------+
 804  *      | room for strings named|
 805  *      | in the structures     |
 806  *      | above.                |
 807  *      +-----------------------+
 808  */
 809 DWORD WINAPI lineGetTranslateCapsA(HLINEAPP hLineApp, DWORD dwAPIVersion,
 810         LPLINETRANSLATECAPS lpTranslateCaps)
 811 {
 812     HKEY hkLocations, hkCards, hkCardLocations, hsubkey;
 813     int numlocations, numcards;
 814     DWORD maxlockeylen,
 815         maxcardkeylen;
 816     char *loc_key_name = NULL;
 817     char *card_key_name = NULL;
 818     LPBYTE strptr;
 819     int length;
 820     int i;
 821     DWORD lendword;
 822     DWORD currentid;
 823     LPLINELOCATIONENTRY pLocEntry;
 824     LPLINECARDENTRY pCardEntry;
 825
 826     TRACE("(%p, %08x, %p (tot. size %d)\n", hLineApp, dwAPIVersion,
 827             lpTranslateCaps, lpTranslateCaps->dwTotalSize );
 828     if( lpTranslateCaps->dwTotalSize < sizeof(LINETRANSLATECAPS))
 829         return LINEERR_STRUCTURETOOSMALL;
 830     if( RegCreateKeyA(HKEY_LOCAL_MACHINE, szLocationsKey, &hkLocations)
 831             != ERROR_SUCCESS ) {
 832         ERR("unexpected registry error 1.\n");
 833         return LINEERR_INIFILECORRUPT;
 834     }
 835     lendword = sizeof( DWORD);
 836     if( RegQueryValueExA( hkLocations, "CurrentID", NULL, NULL,
 837                 (LPBYTE) &currentid, &lendword) != ERROR_SUCCESS )
 838         currentid = -1;  /* change this later */
 839     if(RegQueryInfoKeyA(hkLocations, NULL, NULL, NULL, NULL, &maxlockeylen,
 840                         NULL, NULL, NULL, NULL, NULL, NULL) != ERROR_SUCCESS) {
 841         RegCloseKey(hkLocations);
 842         ERR("unexpected registry error 2.\n");
 843         return LINEERR_INIFILECORRUPT;
 844     }
 845     maxlockeylen++;
 846     if( maxlockeylen < 10)
 847         maxlockeylen = 10; /* need this also if there is no key */
 848     loc_key_name = HeapAlloc( GetProcessHeap(), 0, maxlockeylen);
 849     /* first time through: calculate needed space */
 850     length=0;
 851     i=0;
 852     numlocations=0;
 853     while( RegEnumKeyA(hkLocations, i, loc_key_name, maxlockeylen)
 854             == ERROR_SUCCESS){
 855         DWORD size_val;
 856         i++;
 857         if( _strnicmp(loc_key_name, "location", 8)  ||
 858                 (RegOpenKeyA(hkLocations, loc_key_name, &hsubkey)
 859                  != ERROR_SUCCESS))
 860             continue;
 861         numlocations++;
 862         length += sizeof(LINELOCATIONENTRY);
 863         RegQueryValueExA(hsubkey, "Name",NULL,NULL,NULL,&size_val);
 864         length += size_val;
 865         RegQueryValueExA(hsubkey, "AreaCode",NULL,NULL,NULL,&size_val);
 866         length += size_val;
 867         RegQueryValueExA(hsubkey, "OutsideAccess",NULL,NULL,NULL,&size_val);
 868         length += size_val;
 869         RegQueryValueExA(hsubkey, "LongDistanceAccess",NULL,NULL,NULL,&size_val);
 870         length += size_val;
 871         RegQueryValueExA(hsubkey, "DisableCallWaiting",NULL,NULL,NULL,&size_val);
 872         length += size_val;
 873         /* fixme: what about TollPrefixList???? */
 874         RegCloseKey(hsubkey);
 875     }
 876     if(numlocations == 0) {
 877         /* add one location */
 878         if( RegCreateKeyA( hkLocations, "Location1", &hsubkey)
 879                 == ERROR_SUCCESS) {
 880             DWORD dwval;
 881             char buf[10];
 882             numlocations = 1;
 883             length += sizeof(LINELOCATIONENTRY) + 20 ;
 884             RegSetValueExA( hsubkey, "AreaCode", 0, REG_SZ, (const BYTE *)"010", 4);
 885             GetLocaleInfoA( LOCALE_SYSTEM_DEFAULT, LOCALE_ICOUNTRY, buf, 8);
 886             dwval = atoi(buf);
 887             RegSetValueExA( hsubkey, "Country", 0, REG_DWORD, (LPBYTE)&dwval,
 888                     sizeof(DWORD));
 889             RegSetValueExA( hsubkey, "DisableCallWaiting", 0, REG_SZ, (const BYTE *)"", 1);
 890             dwval = 1;
 891             RegSetValueExA( hsubkey, "Flags", 0, REG_DWORD, (LPBYTE)&dwval,
 892                     sizeof(DWORD));
 893             RegSetValueExA( hsubkey, "LongDistanceAccess", 0, REG_SZ, (const BYTE *)"", 1);
 894             RegSetValueExA( hsubkey, "Name", 0, REG_SZ, (const BYTE *)"New Location", 13);
 895             RegSetValueExA( hsubkey, "OutsideAccess", 0, REG_SZ, (const BYTE *)"", 1);
 896             RegCloseKey(hsubkey);
 897             dwval = 1;
 898             RegSetValueExA( hkLocations, "CurrentID", 0, REG_DWORD,
 899                     (LPBYTE)&dwval, sizeof(DWORD));
 900             dwval = 2;
 901             RegSetValueExA( hkLocations, "NextID", 0, REG_DWORD, (LPBYTE)&dwval,
 902                     sizeof(DWORD));
 903         }
 904     }
 905     /* do the card list */
 906     numcards=0;
 907     if( RegCreateKeyA(HKEY_CURRENT_USER, szCardsKey, &hkCards)
 908             == ERROR_SUCCESS ) {
 909         if(RegQueryInfoKeyA(hkCards, NULL, NULL, NULL, NULL, &maxcardkeylen,
 910                 NULL, NULL, NULL, NULL, NULL, NULL) == ERROR_SUCCESS) {
 911             maxcardkeylen++;
 912             if( maxcardkeylen < 6) maxcardkeylen = 6;
 913             card_key_name = HeapAlloc(GetProcessHeap(), 0, maxcardkeylen);
 914             i=0;
 915             while( RegEnumKeyA(hkCards, i, card_key_name, maxcardkeylen) ==
 916                     ERROR_SUCCESS){
 917                 DWORD size_val;
 918                 i++;
 919                 if( _strnicmp(card_key_name, "card", 4)  || ERROR_SUCCESS !=
 920                         (RegOpenKeyA(hkCards, card_key_name, &hsubkey) ))
 921                     continue;
 922                 numcards++;
 923                 length += sizeof(LINECARDENTRY);
 924                 RegQueryValueExA(hsubkey, "Name",NULL,NULL,NULL,&size_val);
 925                 length += size_val;
 926                 RegQueryValueExA(hsubkey, "LocalRule",NULL,NULL,NULL,&size_val);
 927                 length += size_val;
 928                 RegQueryValueExA(hsubkey, "LDRule",NULL,NULL,NULL,&size_val);
 929                 length += size_val;
 930                 RegQueryValueExA(hsubkey, "InternationalRule",NULL,NULL,NULL,
 931                         &size_val);
 932                 length += size_val;
 933                 RegCloseKey(hsubkey);
 934             }
 935         }
 936         /* add one card (direct call) */
 937         if (numcards == 0 &&
 938                 ERROR_SUCCESS == RegCreateKeyA( hkCards, "Card1", &hsubkey)) {
 939             DWORD dwval;
 940             numcards = 1;
 941             length += sizeof(LINECARDENTRY) + 22 ;
 942             RegSetValueExA( hsubkey, "Name", 0, REG_SZ, (const BYTE *)"None (Direct Call)", 19);
 943             dwval = 1;
 944             RegSetValueExA( hsubkey, "Flags", 0, REG_DWORD, (LPBYTE)&dwval,
 945                     sizeof(DWORD));
 946             RegSetValueExA( hsubkey, "InternationalRule", 0, REG_SZ, (const BYTE *)"", 1);
 947             RegSetValueExA( hsubkey, "LDRule", 0, REG_SZ, (const BYTE *)"", 1);
 948             RegSetValueExA( hsubkey, "LocalRule", 0, REG_SZ, (const BYTE *)"", 1);
 949             RegCloseKey(hsubkey);
 950             dwval = 2;
 951             RegSetValueExA( hkCards, "NextID", 0, REG_DWORD, (LPBYTE)&dwval,
 952                     sizeof(DWORD));
 953         }
 954     } else hkCards = 0;  /* should really fail */
 955     /* check if sufficient room is available */
 956     lpTranslateCaps->dwNeededSize =  sizeof(LINETRANSLATECAPS) + length;
 957     if ( lpTranslateCaps->dwNeededSize > lpTranslateCaps->dwTotalSize ) {
 958         RegCloseKey( hkLocations);
 959         if( hkCards) RegCloseKey( hkCards);
 960         HeapFree(GetProcessHeap(), 0, loc_key_name);
 961         HeapFree(GetProcessHeap(), 0, card_key_name);
 962         lpTranslateCaps->dwUsedSize = sizeof(LINETRANSLATECAPS);
 963         TRACE("Insufficient space: total %d needed %d used %d\n",
 964                 lpTranslateCaps->dwTotalSize,
 965                 lpTranslateCaps->dwNeededSize,
 966                 lpTranslateCaps->dwUsedSize);
 967         return  0;
 968     }
 969     /* fill in the LINETRANSLATECAPS structure */
 970     lpTranslateCaps->dwUsedSize = lpTranslateCaps->dwNeededSize;
 971     lpTranslateCaps->dwNumLocations = numlocations;
 972     lpTranslateCaps->dwLocationListSize = sizeof(LINELOCATIONENTRY) *
 973             lpTranslateCaps->dwNumLocations;
 974     lpTranslateCaps->dwLocationListOffset = sizeof(LINETRANSLATECAPS);
 975     lpTranslateCaps->dwCurrentLocationID = currentid;
 976     lpTranslateCaps->dwNumCards = numcards;
 977     lpTranslateCaps->dwCardListSize = sizeof(LINECARDENTRY) *
 978             lpTranslateCaps->dwNumCards;
 979     lpTranslateCaps->dwCardListOffset = lpTranslateCaps->dwLocationListOffset +
 980             lpTranslateCaps->dwLocationListSize;
 981     lpTranslateCaps->dwCurrentPreferredCardID = 0;
 982     /* this is where the strings will be stored */
 983     strptr = ((LPBYTE) lpTranslateCaps) +
 984         lpTranslateCaps->dwCardListOffset + lpTranslateCaps->dwCardListSize;
 985     pLocEntry = (LPLINELOCATIONENTRY) (lpTranslateCaps + 1);
 986     /* key with Preferred CardIDs */
 987     if( RegOpenKeyA(HKEY_CURRENT_USER, szLocationsKey, &hkCardLocations)
 988             != ERROR_SUCCESS )
 989         hkCardLocations = 0;
 990     /* second time through all locations */
 991     i=0;
 992     while(RegEnumKeyA(hkLocations, i, loc_key_name, maxlockeylen)
 993             == ERROR_SUCCESS){
 994         DWORD size_val;
 995         i++;
 996         if( _strnicmp(loc_key_name, "location", 8)  ||
 997                 (RegOpenKeyA(hkLocations, loc_key_name, &hsubkey)
 998                  != ERROR_SUCCESS))
 999             continue;
1000         size_val=sizeof(DWORD);
1001         if( RegQueryValueExA(hsubkey, "ID",NULL, NULL,
1002                 (LPBYTE) &(pLocEntry->dwPermanentLocationID), &size_val) !=
1003                 ERROR_SUCCESS)
1004             pLocEntry->dwPermanentLocationID = atoi( loc_key_name + 8);
1005         size_val=2048;
1006         RegQueryValueExA(hsubkey, "Name",NULL,NULL, strptr, &size_val);
1007         pLocEntry->dwLocationNameSize = size_val;
1008         pLocEntry->dwLocationNameOffset = strptr - (LPBYTE) lpTranslateCaps;
1009         strptr += size_val;
1010
1011         size_val=2048;
1012         RegQueryValueExA(hsubkey, "AreaCode",NULL,NULL, strptr, &size_val);
1013         pLocEntry->dwCityCodeSize = size_val;
1014         pLocEntry->dwCityCodeOffset = strptr - (LPBYTE) lpTranslateCaps;
1015         strptr += size_val;
1016
1017         size_val=2048;
1018         RegQueryValueExA(hsubkey, "OutsideAccess",NULL,NULL, strptr, &size_val);
1019         pLocEntry->dwLocalAccessCodeSize = size_val;
1020         pLocEntry->dwLocalAccessCodeOffset = strptr - (LPBYTE) lpTranslateCaps;
1021         strptr += size_val;
1022         size_val=2048;
1023         RegQueryValueExA(hsubkey, "LongDistanceAccess",NULL,NULL, strptr,
1024                 &size_val);
1025         pLocEntry->dwLongDistanceAccessCodeSize= size_val;
1026         pLocEntry->dwLongDistanceAccessCodeOffset= strptr -
1027             (LPBYTE) lpTranslateCaps;
1028         strptr += size_val;
1029         size_val=2048;
1030         RegQueryValueExA(hsubkey, "DisableCallWaiting",NULL,NULL, strptr,
1031                 &size_val);
1032         pLocEntry->dwCancelCallWaitingSize= size_val;
1033         pLocEntry->dwCancelCallWaitingOffset= strptr - (LPBYTE) lpTranslateCaps;
1034         strptr += size_val;
1035
1036         pLocEntry->dwTollPrefixListSize = 0;    /* FIXME */
1037         pLocEntry->dwTollPrefixListOffset = 0;    /* FIXME */
1038
1039         size_val=sizeof(DWORD);
1040         RegQueryValueExA(hsubkey, "Country",NULL,NULL,
1041                 (LPBYTE) &(pLocEntry->dwCountryCode), &size_val);
1042         pLocEntry->dwCountryID = pLocEntry->dwCountryCode; /* FIXME */
1043         RegQueryValueExA(hsubkey, "Flags",NULL,NULL,
1044                 (LPBYTE) &(pLocEntry->dwOptions), &size_val);
1045         RegCloseKey(hsubkey);
1046         /* get preferred cardid */
1047         pLocEntry->dwPreferredCardID = 0;
1048         if ( hkCardLocations) {
1049             size_val=sizeof(DWORD);
1050             if(RegOpenKeyA(hkCardLocations, loc_key_name, &hsubkey) ==
1051                     ERROR_SUCCESS) {
1052                 RegQueryValueExA(hsubkey, "CallingCard",NULL,NULL,
1053                         (LPBYTE) &(pLocEntry->dwPreferredCardID), &size_val);
1054                 RegCloseKey(hsubkey);
1055             }
1056
1057         }
1058         /* make sure there is a currentID */
1059         if(currentid == -1){
1060             currentid = pLocEntry->dwPermanentLocationID;
1061             lpTranslateCaps->dwCurrentLocationID = currentid;
1062         }
1063         if(pLocEntry->dwPermanentLocationID == currentid )
1064             lpTranslateCaps->dwCurrentPreferredCardID =
1065                     pLocEntry->dwPreferredCardID;
1066         TRACE("added: ID %d %s CountryCode %d CityCode %s CardID %d "
1067                 "LocalAccess: %s LongDistanceAccess: %s CountryID %d "
1068                 "Options %d CancelCallWait %s\n",
1069                 pLocEntry->dwPermanentLocationID,
1070                 debugstr_a( (char*)lpTranslateCaps + pLocEntry->dwLocationNameOffset),
1071                 pLocEntry->dwCountryCode,
1072                 debugstr_a( (char*)lpTranslateCaps + pLocEntry->dwCityCodeOffset),
1073                 pLocEntry->dwPreferredCardID,
1074                 debugstr_a( (char*)lpTranslateCaps + pLocEntry->dwLocalAccessCodeOffset),
1075                 debugstr_a( (char*)lpTranslateCaps + pLocEntry->dwLongDistanceAccessCodeOffset),
1076                 pLocEntry->dwCountryID,
1077                 pLocEntry->dwOptions,
1078                 debugstr_a( (char*)lpTranslateCaps + pLocEntry->dwCancelCallWaitingOffset));
1079         pLocEntry++;
1080     }
1081     pCardEntry= (LPLINECARDENTRY) pLocEntry;
1082     /* do the card list */
1083     if( hkCards) {
1084         i=0;
1085         while( RegEnumKeyA(hkCards, i, card_key_name, maxcardkeylen) ==
1086                 ERROR_SUCCESS){
1087             DWORD size_val;
1088             i++;
1089             if( _strnicmp(card_key_name, "card", 4)  ||
1090                     (RegOpenKeyA(hkCards, card_key_name, &hsubkey) != ERROR_SUCCESS))
1091                 continue;
1092             size_val=sizeof(DWORD);
1093             if( RegQueryValueExA(hsubkey, "ID",NULL, NULL,
1094                     (LPBYTE) &(pCardEntry->dwPermanentCardID), &size_val) !=
1095                     ERROR_SUCCESS)
1096                 pCardEntry->dwPermanentCardID= atoi( card_key_name + 4);
1097             size_val=2048;
1098             RegQueryValueExA(hsubkey, "Name",NULL,NULL, strptr, &size_val);
1099             pCardEntry->dwCardNameSize = size_val;
1100             pCardEntry->dwCardNameOffset = strptr - (LPBYTE) lpTranslateCaps;
1101             strptr += size_val;
1102             pCardEntry->dwCardNumberDigits = 1; /* FIXME */
1103             size_val=2048;
1104             RegQueryValueExA(hsubkey, "LocalRule",NULL,NULL, strptr, &size_val);
1105             pCardEntry->dwSameAreaRuleSize= size_val;
1106             pCardEntry->dwSameAreaRuleOffset= strptr - (LPBYTE) lpTranslateCaps;
1107             strptr += size_val;
1108             size_val=2048;
1109             RegQueryValueExA(hsubkey, "LDRule",NULL,NULL, strptr, &size_val);
1110             pCardEntry->dwLongDistanceRuleSize = size_val;
1111             pCardEntry->dwLongDistanceRuleOffset = strptr - (LPBYTE) lpTranslateCaps;
1112             strptr += size_val;
1113             size_val=2048;
1114             RegQueryValueExA(hsubkey, "InternationalRule",NULL,NULL, strptr,
1115                     &size_val);
1116             pCardEntry->dwInternationalRuleSize = size_val;
1117             pCardEntry->dwInternationalRuleOffset = strptr -
1118                 (LPBYTE) lpTranslateCaps;
1119             strptr += size_val;
1120             size_val=sizeof(DWORD);
1121             RegQueryValueExA(hsubkey, "Flags",NULL, NULL,
1122                     (LPBYTE) &(pCardEntry->dwOptions), &size_val);
1123             TRACE( "added card: ID %d name %s SameArea %s LongDistance %s International %s Options 0x%x\n",
1124                     pCardEntry->dwPermanentCardID,
1125                     debugstr_a( (char*)lpTranslateCaps + pCardEntry->dwCardNameOffset),
1126                     debugstr_a( (char*)lpTranslateCaps + pCardEntry->dwSameAreaRuleOffset),
1127                     debugstr_a( (char*)lpTranslateCaps + pCardEntry->dwLongDistanceRuleOffset),
1128                     debugstr_a( (char*)lpTranslateCaps + pCardEntry->dwInternationalRuleOffset),
1129                     pCardEntry->dwOptions);
1130
1131             pCardEntry++;
1132         }
1133     }
1134
1135     if(hkLocations) RegCloseKey(hkLocations);
1136     if(hkCards) RegCloseKey(hkCards);
1137     if(hkCardLocations) RegCloseKey(hkCardLocations);
1138     HeapFree(GetProcessHeap(), 0, loc_key_name);
1139     HeapFree(GetProcessHeap(), 0, card_key_name);
1140     TRACE(" returning success tot %d needed %d used %d\n",
1141             lpTranslateCaps->dwTotalSize,
1142             lpTranslateCaps->dwNeededSize,
1143             lpTranslateCaps->dwUsedSize );
1144     return 0; /* success */
1145 }
1146
1147 /***********************************************************************
1148  *              lineHandoff (TAPI32.@)
1149  */
1150 DWORD WINAPI lineHandoffA(HCALL hCall, LPCSTR lpszFileName, DWORD dwMediaMode)
1151 {
1152     FIXME("(%p, %s, %08x): stub.\n", hCall, lpszFileName, dwMediaMode);
1153     return 0;
1154 }
1155
1156 /***********************************************************************
1157  *              lineHold (TAPI32.@)
1158  */
1159 DWORD WINAPI lineHold(HCALL hCall)
1160 {
1161     FIXME("(%p): stub.\n", hCall);
1162     return 1;
1163 }
1164
1165 /***********************************************************************
1166  *              lineInitialize (TAPI32.@)
1167  */
1168 DWORD WINAPI lineInitialize(
1169   LPHLINEAPP lphLineApp,
1170   HINSTANCE hInstance,
1171   LINECALLBACK lpfnCallback,
1172   LPCSTR lpszAppName,
1173   LPDWORD lpdwNumDevs)
1174 {
1175     FIXME("(%p, %p, %p, %s, %p): stub.\n", lphLineApp, hInstance,
1176           lpfnCallback, debugstr_a(lpszAppName), lpdwNumDevs);
1177     return 0;
1178 }
1179
1180 /***********************************************************************
1181  *              lineInitializeExA (TAPI32.@)
1182  */
1183 LONG WINAPI lineInitializeExA(LPHLINEAPP lphLineApp, HINSTANCE hInstance, LINECALLBACK lpfnCallback, LPCSTR lpszFriendlyAppName, LPDWORD lpdwNumDevs, LPDWORD lpdwAPIVersion, LPLINEINITIALIZEEXPARAMS lpLineInitializeExParams)
1184 {
1185     FIXME("(%p, %p, %p, %s, %p, %p, %p): stub.\n", lphLineApp, hInstance,
1186           lpfnCallback, debugstr_a(lpszFriendlyAppName), lpdwNumDevs, lpdwAPIVersion, lpLineInitializeExParams);
1187     return 0;
1188 }
1189
1190 /***********************************************************************
1191  *              lineInitializeExW (TAPI32.@)
1192  */
1193 LONG WINAPI lineInitializeExW(LPHLINEAPP lphLineApp, HINSTANCE hInstance, LINECALLBACK lpfnCallback, LPCWSTR lpszFriendlyAppName, LPDWORD lpdwNumDevs, LPDWORD lpdwAPIVersion, LPLINEINITIALIZEEXPARAMS lpLineInitializeExParams)
1194 {
1195     FIXME("(%p, %p, %p, %s, %p, %p, %p): stub.\n", lphLineApp, hInstance,
1196           lpfnCallback, debugstr_w(lpszFriendlyAppName), lpdwNumDevs, lpdwAPIVersion, lpLineInitializeExParams);
1197     return 0;
1198 }
1199
1200 /***********************************************************************
1201  *              lineMakeCallW (TAPI32.@)
1202  */
1203 DWORD WINAPI lineMakeCallW(HLINE hLine, LPHCALL lphCall, LPCWSTR lpszDestAddress,
1204                            DWORD dwCountryCode, LPLINECALLPARAMS lpCallParams)
1205 {
1206     FIXME("(%p, %p, %s, %08x, %p): stub.\n", hLine, lphCall, debugstr_w(lpszDestAddress),
1207                                              dwCountryCode, lpCallParams);
1208     return LINEERR_OPERATIONFAILED;
1209 }
1210
1211 /***********************************************************************
1212  *              lineMakeCallA (TAPI32.@)
1213  */
1214 DWORD WINAPI lineMakeCallA(HLINE hLine, LPHCALL lphCall, LPCSTR lpszDestAddress,
1215                            DWORD dwCountryCode, LPLINECALLPARAMS lpCallParams)
1216 {
1217     FIXME("(%p, %p, %s, %08x, %p): stub.\n", hLine, lphCall, lpszDestAddress,
1218                                              dwCountryCode, lpCallParams);
1219     return LINEERR_OPERATIONFAILED;
1220 }
1221
1222 /***********************************************************************
1223  *              lineMonitorDigits (TAPI32.@)
1224  */
1225 DWORD WINAPI lineMonitorDigits(HCALL hCall, DWORD dwDigitModes)
1226 {
1227     FIXME("(%p, %08x): stub.\n", hCall, dwDigitModes);
1228     return 0;
1229 }
1230
1231 /***********************************************************************
1232  *              lineMonitorMedia (TAPI32.@)
1233  */
1234 DWORD WINAPI lineMonitorMedia(HCALL hCall, DWORD dwMediaModes)
1235 {
1236     FIXME("(%p, %08x): stub.\n", hCall, dwMediaModes);
1237     return 0;
1238 }
1239
1240 /***********************************************************************
1241  *              lineMonitorTones (TAPI32.@)
1242  */
1243 DWORD WINAPI lineMonitorTones(HCALL hCall, LPLINEMONITORTONE lpToneList, DWORD dwNumEntries)
1244 {
1245     FIXME("(%p, %p, %08x): stub.\n", hCall, lpToneList, dwNumEntries);
1246     return 0;
1247 }
1248
1249 /***********************************************************************
1250  *              lineNegotiateAPIVersion (TAPI32.@)
1251  */
1252 DWORD WINAPI lineNegotiateAPIVersion(
1253   HLINEAPP hLineApp,
1254   DWORD dwDeviceID,
1255   DWORD dwAPILowVersion,
1256   DWORD dwAPIHighVersion,
1257   LPDWORD lpdwAPIVersion,
1258   LPLINEEXTENSIONID lpExtensionID
1259 )
1260 {
1261     static int warn_once;
1262
1263     if(!warn_once++)
1264         FIXME("(%p, %d, %d, %d, %p, %p): stub.\n", hLineApp, dwDeviceID,
1265               dwAPILowVersion, dwAPIHighVersion, lpdwAPIVersion, lpExtensionID);
1266     *lpdwAPIVersion = dwAPIHighVersion;
1267     return 0;
1268 }
1269
1270 /***********************************************************************
1271  *              lineNegotiateExtVersion (TAPI32.@)
1272  */
1273 DWORD WINAPI lineNegotiateExtVersion(HLINEAPP hLineApp, DWORD dwDeviceID, DWORD dwAPIVersion, DWORD dwExtLowVersion, DWORD dwExtHighVersion, LPDWORD lpdwExtVersion)
1274 {
1275     FIXME("stub.\n");
1276     return 0;
1277 }
1278
1279 /***********************************************************************
1280  *              lineOpenW (TAPI32.@)
1281  */
1282 DWORD WINAPI lineOpenW(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  *              lineOpen (TAPI32.@)
1290  */
1291 DWORD WINAPI lineOpenA(HLINEAPP hLineApp, DWORD dwDeviceID, LPHLINE lphLine, DWORD dwAPIVersion, DWORD dwExtVersion, DWORD dwCallbackInstance, DWORD dwPrivileges, DWORD dwMediaModes, LPLINECALLPARAMS lpCallParams)
1292 {
1293     FIXME("stub.\n");
1294     return 0;
1295 }
1296
1297 /***********************************************************************
1298  *              linePark (TAPI32.@)
1299  */
1300 DWORD WINAPI lineParkA(HCALL hCall, DWORD dwParkMode, LPCSTR lpszDirAddress, LPVARSTRING lpNonDirAddress)
1301 {
1302     FIXME("(%p, %08x, %s, %p): stub.\n", hCall, dwParkMode, lpszDirAddress, lpNonDirAddress);
1303     return 1;
1304 }
1305
1306 /***********************************************************************
1307  *              linePickup (TAPI32.@)
1308  */
1309 DWORD WINAPI linePickupA(HLINE hLine, DWORD dwAddressID, LPHCALL lphCall, LPCSTR lpszDestAddress, LPCSTR lpszGroupID)
1310 {
1311     FIXME("(%p, %08x, %p, %s, %s): stub.\n", hLine, dwAddressID, lphCall, lpszDestAddress, lpszGroupID);
1312     return 1;
1313 }
1314
1315 /***********************************************************************
1316  *              linePrepareAddToConference (TAPI32.@)
1317  */
1318 DWORD WINAPI linePrepareAddToConferenceA(HCALL hConfCall, LPHCALL lphConsultCall, LPLINECALLPARAMS lpCallParams)
1319 {
1320     FIXME("(%p, %p, %p): stub.\n", hConfCall, lphConsultCall, lpCallParams);
1321     return 1;
1322 }
1323
1324 /***********************************************************************
1325  *              lineRedirect (TAPI32.@)
1326  */
1327 DWORD WINAPI lineRedirectA(
1328   HCALL hCall,
1329   LPCSTR lpszDestAddress,
1330   DWORD  dwCountryCode) {
1331
1332   FIXME(": stub.\n");
1333   return 1;
1334 }
1335
1336 /***********************************************************************
1337  *              lineRegisterRequestRecipient (TAPI32.@)
1338  */
1339 DWORD WINAPI lineRegisterRequestRecipient(HLINEAPP hLineApp, DWORD dwRegistrationInstance, DWORD dwRequestMode, DWORD dwEnable)
1340 {
1341     FIXME("(%p, %08x, %08x, %08x): stub.\n", hLineApp, dwRegistrationInstance, dwRequestMode, dwEnable);
1342     return 1;
1343 }
1344
1345 /***********************************************************************
1346  *              lineReleaseUserUserInfo (TAPI32.@)
1347  */
1348 DWORD WINAPI lineReleaseUserUserInfo(HCALL hCall)
1349 {
1350     FIXME("(%p): stub.\n", hCall);
1351     return 1;
1352 }
1353
1354 /***********************************************************************
1355  *              lineRemoveFromConference (TAPI32.@)
1356  */
1357 DWORD WINAPI lineRemoveFromConference(HCALL hCall)
1358 {
1359     FIXME("(%p): stub.\n", hCall);
1360     return 1;
1361 }
1362
1363 /***********************************************************************
1364  *              lineRemoveProvider (TAPI32.@)
1365  */
1366 DWORD WINAPI lineRemoveProvider(DWORD dwPermanentProviderID, HWND hwndOwner)
1367 {
1368     FIXME("(%08x, %p): stub.\n", dwPermanentProviderID, hwndOwner);
1369     return 1;
1370 }
1371
1372 /***********************************************************************
1373  *              lineSecureCall (TAPI32.@)
1374  */
1375 DWORD WINAPI lineSecureCall(HCALL hCall)
1376 {
1377     FIXME("(%p): stub.\n", hCall);
1378     return 1;
1379 }
1380
1381 /***********************************************************************
1382  *              lineSendUserUserInfo (TAPI32.@)
1383  */
1384 DWORD WINAPI lineSendUserUserInfo(HCALL hCall, LPCSTR lpsUserUserInfo, DWORD dwSize)
1385 {
1386     FIXME("(%p, %s, %08x): stub.\n", hCall, lpsUserUserInfo, dwSize);
1387     return 1;
1388 }
1389
1390 /***********************************************************************
1391  *              lineSetAppPriority (TAPI32.@)
1392  */
1393 DWORD WINAPI lineSetAppPriorityA(LPCSTR lpszAppFilename, DWORD dwMediaMode, LPLINEEXTENSIONID const lpExtensionID, DWORD dwRequestMode, LPCSTR lpszExtensionName, DWORD dwPriority)
1394 {
1395     FIXME("(%s, %08x, %p, %08x, %s, %08x): stub.\n", lpszAppFilename, dwMediaMode, lpExtensionID, dwRequestMode, lpszExtensionName, dwPriority);
1396     return 0;
1397 }
1398
1399 /***********************************************************************
1400  *              lineSetAppSpecific (TAPI32.@)
1401  */
1402 DWORD WINAPI lineSetAppSpecific(HCALL hCall, DWORD dwAppSpecific)
1403 {
1404     FIXME("(%p, %08x): stub.\n", hCall, dwAppSpecific);
1405     return 0;
1406 }
1407
1408 /***********************************************************************
1409  *              lineSetCallParams (TAPI32.@)
1410  */
1411 DWORD WINAPI lineSetCallParams(HCALL hCall, DWORD dwBearerMode, DWORD dwMinRate, DWORD dwMaxRate, LPLINEDIALPARAMS lpDialParams)
1412 {
1413     FIXME("(%p, %08x, %08x, %08x, %p): stub.\n", hCall, dwBearerMode, dwMinRate, dwMaxRate, lpDialParams);
1414     return 1;
1415 }
1416
1417 /***********************************************************************
1418  *              lineSetCallPrivilege (TAPI32.@)
1419  */
1420 DWORD WINAPI lineSetCallPrivilege(HCALL hCall, DWORD dwCallPrivilege)
1421 {
1422     FIXME("(%p, %08x): stub.\n", hCall, dwCallPrivilege);
1423     return 0;
1424 }
1425
1426 /***********************************************************************
1427  *              lineSetCurrentLocation (TAPI32.@)
1428  */
1429 DWORD WINAPI lineSetCurrentLocation(HLINEAPP hLineApp, DWORD dwLocation)
1430 {
1431     FIXME("(%p, %08x): stub.\n", hLineApp, dwLocation);
1432     return 0;
1433 }
1434
1435 /***********************************************************************
1436  *              lineSetDevConfig (TAPI32.@)
1437  */
1438 DWORD WINAPI lineSetDevConfigA(DWORD dwDeviceID, LPVOID lpDeviceConfig, DWORD dwSize, LPCSTR lpszDeviceClass)
1439 {
1440     FIXME("(%08x, %p, %08x, %s): stub.\n", dwDeviceID, lpDeviceConfig, dwSize, lpszDeviceClass);
1441     return 0;
1442 }
1443
1444 /***********************************************************************
1445  *              lineSetMediaControl (TAPI32.@)
1446  */
1447 DWORD WINAPI lineSetMediaControl(
1448 HLINE hLine,
1449 DWORD dwAddressID,
1450 HCALL hCall,
1451 DWORD dwSelect,
1452 LPLINEMEDIACONTROLDIGIT const lpDigitList,
1453 DWORD dwDigitNumEntries,
1454 LPLINEMEDIACONTROLMEDIA const lpMediaList,
1455 DWORD dwMediaNumEntries,
1456 LPLINEMEDIACONTROLTONE const lpToneList,
1457 DWORD dwToneNumEntries,
1458 LPLINEMEDIACONTROLCALLSTATE const lpCallStateList,
1459 DWORD dwCallStateNumEntries)
1460 {
1461     FIXME(": stub.\n");
1462     return 0;
1463 }
1464
1465 /***********************************************************************
1466  *              lineSetMediaMode (TAPI32.@)
1467  */
1468 DWORD WINAPI lineSetMediaMode(HCALL hCall, DWORD dwMediaModes)
1469 {
1470     FIXME("(%p, %08x): stub.\n", hCall, dwMediaModes);
1471     return 0;
1472 }
1473
1474 /***********************************************************************
1475  *              lineSetNumRings (TAPI32.@)
1476  */
1477 DWORD WINAPI lineSetNumRings(HLINE hLine, DWORD dwAddressID, DWORD dwNumRings)
1478 {
1479     FIXME("(%p, %08x, %08x): stub.\n", hLine, dwAddressID, dwNumRings);
1480     return 0;
1481 }
1482
1483 /***********************************************************************
1484  *              lineSetStatusMessages (TAPI32.@)
1485  */
1486 DWORD WINAPI lineSetStatusMessages(HLINE hLine, DWORD dwLineStates, DWORD dwAddressStates)
1487 {
1488     FIXME("(%p, %08x, %08x): stub.\n", hLine, dwLineStates, dwAddressStates);
1489     return 0;
1490 }
1491
1492 /***********************************************************************
1493  *              lineSetTerminal (TAPI32.@)
1494  */
1495 DWORD WINAPI lineSetTerminal(HLINE hLine, DWORD dwAddressID, HCALL hCall, DWORD dwSelect, DWORD dwTerminalModes, DWORD dwTerminalID, DWORD bEnable)
1496 {
1497     FIXME("(%p, %08x, %p, %08x, %08x, %08x, %08x): stub.\n", hLine, dwAddressID, hCall, dwSelect, dwTerminalModes, dwTerminalID, bEnable);
1498     return 1;
1499 }
1500
1501 /***********************************************************************
1502  *              lineSetTollList (TAPI32.@)
1503  */
1504 DWORD WINAPI lineSetTollListA(HLINEAPP hLineApp, DWORD dwDeviceID, LPCSTR lpszAddressIn, DWORD dwTollListOption)
1505 {
1506     FIXME("(%p, %08x, %s, %08x): stub.\n", hLineApp, dwDeviceID, lpszAddressIn, dwTollListOption);
1507     return 0;
1508 }
1509
1510 /***********************************************************************
1511  *              lineSetupConference (TAPI32.@)
1512  */
1513 DWORD WINAPI lineSetupConferenceA(HCALL hCall, HLINE hLine, LPHCALL lphConfCall, LPHCALL lphConsultCall, DWORD dwNumParties, LPLINECALLPARAMS lpCallParams)
1514 {
1515     FIXME("(%p, %p, %p, %p, %08x, %p): stub.\n", hCall, hLine, lphConfCall, lphConsultCall, dwNumParties, lpCallParams);
1516     return 1;
1517 }
1518
1519 /***********************************************************************
1520  *              lineSetupTransfer (TAPI32.@)
1521  */
1522 DWORD WINAPI lineSetupTransferA(HCALL hCall, LPHCALL lphConsultCall, LPLINECALLPARAMS lpCallParams)
1523 {
1524     FIXME("(%p, %p, %p): stub.\n", hCall, lphConsultCall, lpCallParams);
1525     return 1;
1526 }
1527
1528 /***********************************************************************
1529  *              lineShutdown (TAPI32.@)
1530  */
1531 DWORD WINAPI lineShutdown(HLINEAPP hLineApp)
1532 {
1533     FIXME("(%p): stub.\n", hLineApp);
1534     return 0;
1535 }
1536
1537 /***********************************************************************
1538  *              lineSwapHold (TAPI32.@)
1539  */
1540 DWORD WINAPI lineSwapHold(HCALL hActiveCall, HCALL hHeldCall)
1541 {
1542     FIXME("(active: %p, held: %p): stub.\n", hActiveCall, hHeldCall);
1543     return 1;
1544 }
1545
1546 /***********************************************************************
1547  *              lineTranslateAddress (TAPI32.@)
1548  */
1549 DWORD WINAPI lineTranslateAddressA(HLINEAPP hLineApp, DWORD dwDeviceID, DWORD dwAPIVersion, LPCSTR lpszAddressIn, DWORD dwCard, DWORD dwTranslateOptions, LPLINETRANSLATEOUTPUT lpTranslateOutput)
1550 {
1551     FIXME("(%p, %08x, %08x, %s, %08x, %08x, %p): stub.\n", hLineApp, dwDeviceID, dwAPIVersion, lpszAddressIn, dwCard, dwTranslateOptions, lpTranslateOutput);
1552     return 0;
1553 }
1554
1555 /***********************************************************************
1556  *              lineTranslateAddressW (TAPI32.@)
1557  */
1558 DWORD WINAPI lineTranslateAddressW(HLINEAPP hLineApp, DWORD dwDeviceID,
1559         DWORD dwAPIVersion, LPCWSTR lpszAddressIn, DWORD dwCard,
1560         DWORD dwTranslateOptions, LPLINETRANSLATEOUTPUT lpTranslateOutput)
1561 {
1562     FIXME("(%p, %08x, %08x, %s, %08x, %08x, %p): stub.\n", hLineApp, dwDeviceID, dwAPIVersion,
1563             debugstr_w(lpszAddressIn), dwCard, dwTranslateOptions, lpTranslateOutput);
1564     return 0;
1565 }
1566
1567 /***********************************************************************
1568  *              lineTranslateDialog (TAPI32.@)
1569  */
1570 DWORD WINAPI lineTranslateDialogA(HLINEAPP hLineApp, DWORD dwDeviceID, DWORD dwAPIVersion, HWND hwndOwner, LPCSTR lpszAddressIn)
1571 {
1572     FIXME("(%p, %08x, %08x, %p, %s): stub.\n", hLineApp, dwDeviceID, dwAPIVersion, hwndOwner, lpszAddressIn);
1573     return 0;
1574 }
1575
1576 /***********************************************************************
1577  *              lineTranslateDialogW (TAPI32.@)
1578  */
1579 DWORD WINAPI lineTranslateDialogW(HLINEAPP hLineApp, DWORD dwDeviceID,
1580         DWORD dwAPIVersion, HWND hwndOwner, LPCWSTR lpszAddressIn)
1581 {
1582     FIXME("(%p, %08x, %08x, %p, %s): stub.\n", hLineApp, dwDeviceID,
1583             dwAPIVersion, hwndOwner, debugstr_w(lpszAddressIn));
1584     return 0;
1585 }
1586
1587 /***********************************************************************
1588  *              lineUncompleteCall (TAPI32.@)
1589  */
1590 DWORD WINAPI lineUncompleteCall(HLINE hLine, DWORD dwCompletionID)
1591 {
1592     FIXME("(%p, %08x): stub.\n", hLine, dwCompletionID);
1593     return 1;
1594 }
1595
1596 /***********************************************************************
1597  *              lineUnhold (TAPI32.@)
1598  */
1599 DWORD WINAPI lineUnhold(HCALL hCall)
1600 {
1601     FIXME("(%p): stub.\n", hCall);
1602     return 1;
1603 }
1604
1605 /***********************************************************************
1606  *              lineUnpark (TAPI32.@)
1607  */
1608 DWORD WINAPI lineUnparkA(HLINE hLine, DWORD dwAddressID, LPHCALL lphCall, LPCSTR lpszDestAddress)
1609 {
1610     FIXME("(%p, %08x, %p, %s): stub.\n", hLine, dwAddressID, lphCall, lpszDestAddress);
1611     return 1;
1612 }