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