dll/win32/tapi32/line.c

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