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