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