xref: /reactos/dll/win32/mswsock/mswhelper.c (revision 40462c92) 
1 
2 #include "precomp.h"
3 
4 #include <winuser.h>
5 #include <winnls.h>
6 #include <wchar.h>
7 #include <sal.h>
8 
9 #include "mswhelper.h"
10 
11 #define MSW_BUFSIZE 512
12 #define MAX_ARRAY_SIZE 5
13 
14 void
15 mswBufferInit(_Inout_ PMSW_BUFFER mswBuf,
16               _In_ BYTE* buffer,
17               _In_ DWORD bufferSize)
18 {
19     RtlZeroMemory(mswBuf, sizeof(*mswBuf));
20     RtlZeroMemory(buffer, bufferSize);
21     mswBuf->bytesMax = bufferSize;
22     mswBuf->buffer = buffer;
23     mswBuf->bufendptr = buffer;
24     mswBuf->bufok = TRUE;
25 }
26 
27 BOOL
28 mswBufferCheck(_Inout_ PMSW_BUFFER mswBuf,
29                _In_ DWORD count)
30 {
31     if (mswBuf->bytesUsed + count <= mswBuf->bytesMax)
32         return TRUE;
33 
34     mswBuf->bufok = FALSE;
35     return FALSE;
36 }
37 
38 BOOL
39 mswBufferIncUsed(_Inout_ PMSW_BUFFER mswBuf,
40                  _In_ DWORD count)
41 {
42     if (!mswBufferCheck(mswBuf, count))
43         return FALSE;
44 
45     mswBuf->bytesUsed += count;
46     mswBuf->bufendptr += count;
47     return TRUE;
48 }
49 
50 BYTE*
51 mswBufferEndPtr(_Inout_ PMSW_BUFFER mswBuf)
52 {
53     return mswBuf->bufendptr;
54 }
55 
56 BOOL
57 mswBufferAppend(_Inout_ PMSW_BUFFER mswBuf,
58                 _In_ void *dataToAppend,
59                 _In_ DWORD dataSize)
60 {
61     if (!mswBufferCheck(mswBuf, dataSize))
62         return FALSE;
63 
64     RtlCopyMemory(mswBuf->bufendptr, dataToAppend, dataSize);
65     mswBuf->bytesUsed += dataSize;
66     mswBuf->bufendptr += dataSize;
67 
68     return TRUE;
69 }
70 
71 BOOL mswBufferAppendStrA(_Inout_ PMSW_BUFFER mswBuf,
72                          _In_ char* str)
73 {
74     return mswBufferAppend(mswBuf, str, strlen(str) + sizeof(char));
75 }
76 
77 BOOL
78 mswBufferAppendStrW(_Inout_ PMSW_BUFFER mswBuf,
79                     _In_ WCHAR* str)
80 {
81     int bytelen = (wcslen(str) + 1) * sizeof(WCHAR);
82     return mswBufferAppend(mswBuf, str, bytelen);
83 }
84 
85 BOOL
86 mswBufferAppendPtr(_Inout_ PMSW_BUFFER mswBuf,
87                    _In_ void* ptr)
88 {
89     return mswBufferAppend(mswBuf, &ptr, sizeof(ptr));
90 }
91 
92 /* lst = pointer to pointer of items
93 
94    *lst[0] = 1st item
95    *lst[1] = 2nd item
96    ...
97    lst[n] = NULL = End of List
98 
99    itemLength = data in Bytes for each item.
100 
101    ptrofs = delta relative to mswBuf.buffer
102 */
103 BOOL
104 mswBufferAppendLst(_Inout_ PMSW_BUFFER mswBuf,
105                    _In_ void **lst,
106                    _In_ DWORD itemByteLength,
107                    _In_opt_ int ptrofs)
108 {
109     DWORD lstItemCount;
110     DWORD lstByteSize;
111     DWORD_PTR lstDataPos;
112     DWORD i1;
113     UINT_PTR *ptrSrcLstPos;
114 
115     /* calculate size of list */
116     ptrSrcLstPos = (UINT_PTR*)lst;
117     lstItemCount = 0;
118     while (*ptrSrcLstPos != (UINT_PTR)NULL)
119     {
120         lstItemCount++;
121         ptrSrcLstPos++;
122     }
123 
124     lstByteSize = ((lstItemCount + 1) * sizeof(UINT_PTR)) + /* item-pointer + null-ptr (for end) */
125                   (lstItemCount * itemByteLength); /* item-data */
126 
127     if (mswBuf->bytesUsed + lstByteSize > mswBuf->bytesMax)
128         return FALSE;
129 
130     /* calculate position for the data of the first item */
131     lstDataPos = ((lstItemCount + 1) * sizeof(UINT_PTR)) +
132                  (DWORD_PTR)mswBufferEndPtr(mswBuf);
133     /* add ptrofs */
134     lstDataPos += ptrofs;
135 
136     /* write array of Pointer to data */
137     for (i1 = 0; i1 < lstItemCount; i1++)
138     {
139         if (!mswBufferAppendPtr(mswBuf, (void*)lstDataPos))
140             return FALSE;
141 
142         lstDataPos += sizeof(UINT_PTR);
143     }
144 
145     /* end of list */
146     if (!mswBufferAppendPtr(mswBuf, NULL))
147         return FALSE;
148 
149     /* write data */
150     ptrSrcLstPos = (UINT_PTR*)lst;
151     for (i1 = 0; i1 < lstItemCount; i1++)
152     {
153         mswBufferAppend(mswBuf, *(BYTE**)ptrSrcLstPos, itemByteLength);
154         ptrSrcLstPos++;
155     }
156     return mswBuf->bufok;
157 }
158 
159 BOOL
160 mswBufferAppendStrLstA(_Inout_ PMSW_BUFFER mswBuf,
161                        _In_ void **lst,
162                        _In_opt_ int ptrofs)
163 {
164     DWORD lstItemLen[MAX_ARRAY_SIZE];
165     DWORD lstItemCount;
166     DWORD lstByteSize;
167     DWORD_PTR lstDataPos;
168     DWORD lstDataSize;
169     DWORD i1;
170     UINT_PTR *ptrSrcLstPos;
171 
172     /* calculate size of list */
173     ptrSrcLstPos = (UINT_PTR*)lst;
174     lstItemCount = 0;
175     lstDataSize = 0;
176 
177     while (*ptrSrcLstPos != (UINT_PTR)NULL)
178     {
179         if (lstItemCount >= MAX_ARRAY_SIZE)
180             return FALSE;
181 
182         i1 = strlen((char*)*ptrSrcLstPos) + sizeof(char);
183         lstItemLen[lstItemCount] = i1;
184         lstItemCount++;
185         lstDataSize += i1;
186         ptrSrcLstPos++;
187     }
188 
189     lstByteSize = ((lstItemCount + 1) * sizeof(UINT_PTR)) + /* item-pointer + null-ptr (for end) */
190                   lstDataSize; /* item-data */
191 
192     if (mswBuf->bytesUsed + lstByteSize > mswBuf->bytesMax)
193         return FALSE;
194 
195     /* calculate position for the data of the first item */
196     lstDataPos = ((lstItemCount + 1) * sizeof(UINT_PTR)) +
197                  (DWORD_PTR)mswBufferEndPtr(mswBuf);
198 
199     /* add ptrofs */
200     lstDataPos += ptrofs;
201 
202     for (i1 = 0; i1 < lstItemCount; i1++)
203     {
204         if (!mswBufferAppendPtr(mswBuf, (void*)lstDataPos))
205             return FALSE;
206 
207         lstDataPos += lstItemLen[i1];
208     }
209 
210     /* end of list */
211     if (!mswBufferAppendPtr(mswBuf, NULL))
212         return FALSE;
213 
214     /* write data */
215     ptrSrcLstPos = (UINT_PTR*)lst;
216     for (i1 = 0; i1 < lstItemCount; i1++)
217     {
218         if (!mswBufferAppendStrA(mswBuf, *(char**)ptrSrcLstPos))
219             return FALSE;
220 
221         ptrSrcLstPos++;
222     }
223     return mswBuf->bufok;
224 }
225 
226 BOOL
227 mswBufferAppendBlob_Hostent(_Inout_ PMSW_BUFFER mswBuf,
228                             _Inout_ LPWSAQUERYSETW lpRes,
229                             _In_ char** hostAliasesA,
230                             _In_ char* hostnameA,
231                             _In_ DWORD ip4addr)
232 {
233     PHOSTENT phe;
234     void* lst[2];
235     BYTE* bytesOfs;
236 
237     /* blob */
238     lpRes->lpBlob = (LPBLOB)mswBufferEndPtr(mswBuf);
239 
240     if (!mswBufferIncUsed(mswBuf, sizeof(*lpRes->lpBlob)))
241         return FALSE;
242 
243     /* cbSize will be set later */
244     lpRes->lpBlob->cbSize = 0;
245     lpRes->lpBlob->pBlobData = mswBufferEndPtr(mswBuf);
246 
247     /* hostent */
248     phe = (PHOSTENT)lpRes->lpBlob->pBlobData;
249     bytesOfs = mswBufferEndPtr(mswBuf);
250 
251     if (!mswBufferIncUsed(mswBuf, sizeof(*phe)))
252         return FALSE;
253 
254     phe->h_addrtype = AF_INET;
255     phe->h_length = 4; /* 4 Byte (IPv4) */
256 
257     /* aliases */
258     phe->h_aliases = (char**)(mswBufferEndPtr(mswBuf) - bytesOfs);
259 
260     if (hostAliasesA)
261     {
262         if (!mswBufferAppendStrLstA(mswBuf,
263                                     (void**)hostAliasesA,
264                                     -(LONG_PTR)bytesOfs))
265             return FALSE;
266     }
267     else
268     {
269         if (!mswBufferAppendPtr(mswBuf, NULL))
270             return FALSE;
271     }
272 
273     /* addr_list */
274     RtlZeroMemory(lst, sizeof(lst));
275 
276     lst[0] = (void*)&ip4addr;
277 
278     phe->h_addr_list = (char**)(mswBufferEndPtr(mswBuf) - bytesOfs);
279 
280     if (!mswBufferAppendLst(mswBuf, lst, 4, -(LONG_PTR)bytesOfs))
281         return FALSE;
282 
283     /* name */
284     phe->h_name = (char*)(mswBufferEndPtr(mswBuf) - bytesOfs);
285 
286     if (!mswBufferAppendStrA(mswBuf, hostnameA))
287         return FALSE;
288 
289     lpRes->lpBlob->cbSize = (DWORD)(mswBufferEndPtr(mswBuf) - bytesOfs);
290     return mswBuf->bufok;
291 }
292 
293 BOOL
294 mswBufferAppendBlob_Servent(_Inout_ PMSW_BUFFER mswBuf,
295                             _Inout_ LPWSAQUERYSETW lpRes,
296                             _In_ char* serviceNameA,
297                             _In_ char** serviceAliasesA,
298                             _In_ char* protocolNameA,
299                             _In_ WORD port)
300 {
301     PSERVENT pse;
302     BYTE* bytesOfs;
303 
304     /* blob */
305     lpRes->lpBlob = (LPBLOB)mswBufferEndPtr(mswBuf);
306 
307     if (!mswBufferIncUsed(mswBuf, sizeof(*lpRes->lpBlob)))
308         return FALSE;
309 
310     lpRes->lpBlob->cbSize = 0;//later
311     lpRes->lpBlob->pBlobData = mswBufferEndPtr(mswBuf);
312 
313     /* servent */
314     pse = (LPSERVENT)lpRes->lpBlob->pBlobData;
315     bytesOfs = mswBufferEndPtr(mswBuf);
316 
317     if (!mswBufferIncUsed(mswBuf, sizeof(*pse)))
318         return FALSE;
319 
320     pse->s_aliases = (char**)(mswBufferEndPtr(mswBuf) - bytesOfs);
321 
322     if (serviceAliasesA)
323     {
324         if (!mswBufferAppendStrLstA(mswBuf,
325                                     (void**)serviceAliasesA,
326                                     -(LONG_PTR)bytesOfs))
327             return FALSE;
328     }
329     else
330     {
331         if (!mswBufferAppendPtr(mswBuf, NULL))
332             return FALSE;
333     }
334 
335     pse->s_name = (char*)(mswBufferEndPtr(mswBuf) - bytesOfs);
336 
337     if (!mswBufferAppendStrA(mswBuf, serviceNameA))
338         return FALSE;
339 
340     pse->s_port = htons(port);
341 
342     pse->s_proto = (char*)(mswBufferEndPtr(mswBuf) - bytesOfs);
343 
344     if (!mswBufferAppendStrA(mswBuf, protocolNameA))
345         return FALSE;
346 
347     lpRes->lpBlob->cbSize = (DWORD)(mswBufferEndPtr(mswBuf) - bytesOfs);
348     return mswBuf->bufok;
349 }
350 
351 BOOL
352 mswBufferAppendAddr_AddrInfoW(_Inout_ PMSW_BUFFER mswBuf,
353                               _Inout_ LPWSAQUERYSETW lpRes,
354                               _In_ DWORD ip4addr)
355 {
356     LPCSADDR_INFO paddrinfo;
357     LPSOCKADDR_IN psa;
358 
359     lpRes->dwNumberOfCsAddrs = 1;
360     lpRes->lpcsaBuffer = (LPCSADDR_INFO)mswBufferEndPtr(mswBuf);
361 
362     paddrinfo = lpRes->lpcsaBuffer;
363 
364     if (!mswBufferIncUsed(mswBuf, sizeof(*paddrinfo)))
365         return FALSE;
366 
367     paddrinfo->LocalAddr.lpSockaddr = (LPSOCKADDR)mswBufferEndPtr(mswBuf);
368 
369     if (!mswBufferIncUsed(mswBuf, sizeof(*paddrinfo->LocalAddr.lpSockaddr)))
370         return FALSE;
371 
372     paddrinfo->RemoteAddr.lpSockaddr = (LPSOCKADDR)mswBufferEndPtr(mswBuf);
373 
374     if (!mswBufferIncUsed(mswBuf, sizeof(*paddrinfo->RemoteAddr.lpSockaddr)))
375         return FALSE;
376 
377     paddrinfo->iSocketType = SOCK_DGRAM;
378     paddrinfo->iProtocol = IPPROTO_UDP;
379 
380     psa = (LPSOCKADDR_IN)paddrinfo->LocalAddr.lpSockaddr;
381     paddrinfo->LocalAddr.iSockaddrLength = sizeof(*psa);
382     psa->sin_family = AF_INET;
383     psa->sin_port = 0;
384     psa->sin_addr.s_addr = 0;
385     RtlZeroMemory(psa->sin_zero, sizeof(psa->sin_zero));
386 
387     psa = (LPSOCKADDR_IN)paddrinfo->RemoteAddr.lpSockaddr;
388     paddrinfo->RemoteAddr.iSockaddrLength = sizeof(*psa);
389     psa->sin_family = AF_INET;
390     psa->sin_port = 0;
391     psa->sin_addr.s_addr = ip4addr;
392     RtlZeroMemory(psa->sin_zero, sizeof(psa->sin_zero));
393 
394     return TRUE;
395 }
396 
397 /* ansicode <-> unicode */
398 WCHAR*
399 StrA2WHeapAlloc(_In_opt_ HANDLE hHeap,
400                 _In_ char* aStr)
401 {
402     int aStrByteLen;
403     int wStrByteLen;
404     int charLen;
405     int ret;
406     WCHAR* wStr;
407 
408     if (aStr == NULL)
409         return NULL;
410 
411     charLen = strlen(aStr) + 1;
412 
413     aStrByteLen = (charLen * sizeof(char));
414     wStrByteLen = (charLen * sizeof(WCHAR));
415 
416     if (hHeap == 0)
417         hHeap = GetProcessHeap();
418 
419     wStr = HeapAlloc(hHeap, 0, wStrByteLen);
420     if (wStr == NULL)
421     {
422         HeapFree(hHeap, 0, wStr);
423         return NULL;
424     }
425 
426     ret = MultiByteToWideChar(CP_ACP,
427                               0,
428                               aStr,
429                               aStrByteLen,
430                               wStr,
431                               charLen);
432 
433     if (ret != charLen)
434     {
435         HeapFree(hHeap, 0, wStr);
436         return NULL;
437     }
438     return wStr;
439 }
440 
441 char*
442 StrW2AHeapAlloc(_In_opt_ HANDLE hHeap,
443                 _In_ WCHAR* wStr)
444 {
445     int charLen;
446     int aStrByteLen;
447     int ret;
448     char* aStr;
449 
450     if (wStr == NULL)
451         return NULL;
452 
453     charLen = wcslen(wStr) + 1;
454 
455     aStrByteLen = (charLen * sizeof(char));
456 
457     if (hHeap == 0)
458         hHeap = GetProcessHeap();
459 
460     aStr = HeapAlloc(hHeap, 0, aStrByteLen);
461     if (aStr == NULL)
462     {
463         HeapFree(hHeap, 0, aStr);
464         return NULL;
465     }
466 
467     ret = WideCharToMultiByte(CP_ACP,
468                               0,
469                               wStr,
470                               charLen,
471                               aStr,
472                               aStrByteLen,
473                               NULL,
474                               NULL);
475     if (ret != aStrByteLen)
476     {
477         HeapFree(hHeap, 0, aStr);
478         return NULL;
479     }
480     return aStr;
481 }
482 
483 WCHAR*
484 StrCpyHeapAllocW(_In_opt_ HANDLE hHeap,
485                  _In_ WCHAR* wStr)
486 {
487     size_t chLen;
488     size_t bLen;
489     WCHAR* resW;
490 
491     if (wStr == NULL)
492         return NULL;
493 
494     if (hHeap == 0)
495         hHeap = GetProcessHeap();
496 
497     chLen = wcslen(wStr);
498 
499     bLen = (chLen + 1) * sizeof(WCHAR);
500 
501     resW = HeapAlloc(hHeap, 0, bLen);
502     RtlCopyMemory(resW, wStr, bLen);
503     return resW;
504 }
505 
506 char*
507 StrCpyHeapAllocA(_In_opt_ HANDLE hHeap,
508                  _In_ char* aStr)
509 {
510     size_t chLen;
511     size_t bLen;
512     char* resA;
513 
514     if (aStr == NULL)
515         return NULL;
516 
517     if (hHeap == 0)
518         hHeap = GetProcessHeap();
519 
520     chLen = strlen(aStr);
521 
522     bLen = (chLen + 1) * sizeof(char);
523 
524     resA = HeapAlloc(hHeap, 0, bLen);
525     RtlCopyMemory(resA, aStr, bLen);
526     return resA;
527 }
528 
529 char**
530 StrAryCpyHeapAllocA(_In_opt_ HANDLE hHeap,
531                     _In_ char** aStrAry)
532 {
533     char** aSrcPtr;
534     char** aDstPtr;
535     char* aDstNextStr;
536     DWORD aStrByteLen[MAX_ARRAY_SIZE];
537     size_t bLen;
538     size_t bItmLen;
539     int aCount;
540     int i1;
541     char** resA;
542 
543     if (hHeap == 0)
544         hHeap = GetProcessHeap();
545 
546     /* Calculating size of array ... */
547     aSrcPtr = aStrAry;
548     bLen = 0;
549     aCount = 0;
550 
551     while (*aSrcPtr != NULL)
552     {
553         if (aCount >= MAX_ARRAY_SIZE)
554             return NULL;
555 
556         bItmLen = strlen(*aSrcPtr) + 1;
557         aStrByteLen[aCount] = bItmLen;
558 
559         bLen += sizeof(*aSrcPtr) + bItmLen;
560 
561         aSrcPtr++;
562         aCount++;
563     }
564 
565     /* size for NULL-terminator */
566     bLen += sizeof(*aSrcPtr);
567 
568     /* get memory */
569     resA = HeapAlloc(hHeap, 0, bLen);
570 
571     /* copy data */
572     aSrcPtr = aStrAry;
573     aDstPtr = resA;
574 
575     /* pos for the first string */
576     aDstNextStr = (char*)(resA + aCount + 1);
577     for (i1 = 0; i1 < aCount; i1++)
578     {
579         bItmLen = aStrByteLen[i1];
580 
581         *aDstPtr = aDstNextStr;
582         RtlCopyMemory(*aDstPtr, *aSrcPtr, bItmLen);
583 
584         aDstNextStr = (char*)((DWORD_PTR)aDstNextStr + (DWORD)bItmLen);
585         aDstPtr++;
586         aSrcPtr++;
587     }
588 
589     /* terminate with NULL */
590     *aDstPtr = NULL;
591 
592     return resA;
593 }
594 
595 char**
596 StrAryCpyHeapAllocWToA(_In_opt_ HANDLE hHeap,
597     _In_ WCHAR** wStrAry)
598 {
599     WCHAR** wSrcPtr;
600     char** aDstPtr;
601     char* aDstNextStr;
602     DWORD aStrByteLen[MAX_ARRAY_SIZE];
603     int bLen;
604     int bItmLen;
605     int aCount;
606     int i1;
607     char** resA;
608     int ret;
609     char* aStr;
610 
611     if (hHeap == 0)
612         hHeap = GetProcessHeap();
613 
614     /* Calculating size of array ... */
615     wSrcPtr = wStrAry;
616     bLen = 0;
617     aCount = 0;
618 
619     while (*wSrcPtr != NULL)
620     {
621         if (aCount >= MAX_ARRAY_SIZE)
622             return NULL;
623 
624         bItmLen = wcslen(*wSrcPtr) + 1;
625         aStrByteLen[aCount] = bItmLen;
626 
627         bLen += sizeof(*wSrcPtr) + bItmLen;
628 
629         wSrcPtr++;
630         aCount++;
631     }
632 
633     /* size for NULL-terminator */
634     bLen += sizeof(*wSrcPtr);
635 
636     /* get memory */
637     resA = HeapAlloc(hHeap, 0, bLen);
638 
639     /* copy data */
640     wSrcPtr = wStrAry;
641     aDstPtr = resA;
642 
643     /* pos for the first string */
644     aDstNextStr = (char*)(resA + aCount + 1);
645     for (i1 = 0; i1 < aCount; i1++)
646     {
647         bItmLen = aStrByteLen[i1];
648 
649         *aDstPtr = aDstNextStr;
650 
651         aStr = HeapAlloc(hHeap, 0, bItmLen);
652         if (aStr == NULL)
653         {
654             HeapFree(hHeap, 0, aStr);
655             return NULL;
656         }
657 
658         ret = WideCharToMultiByte(CP_ACP,
659                                   0,
660                                   *wSrcPtr,
661                                   bItmLen,
662                                   aStr,
663                                   bItmLen,
664                                   NULL,
665                                   NULL);
666         if (ret != bItmLen)
667         {
668             HeapFree(hHeap, 0, aStr);
669             return NULL;
670         }
671         RtlCopyMemory(*aDstPtr, aStr, bItmLen);
672         HeapFree(hHeap, 0, aStr);
673 
674         aDstNextStr = (char*)((DWORD_PTR)aDstNextStr + (DWORD)bItmLen);
675         aDstPtr++;
676         wSrcPtr++;
677     }
678 
679     /* terminate with NULL */
680     *aDstPtr = NULL;
681 
682     return resA;
683 }
684