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