projects / reactos.git / blob
? search:


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