diff options
author | Christian Grothoff <christian@grothoff.org> | 2012-09-28 07:51:03 +0000 |
---|---|---|
committer | Christian Grothoff <christian@grothoff.org> | 2012-09-28 07:51:03 +0000 |
commit | 0a99d7b72bd98fddabf16920a9e0129fbf8e0521 (patch) | |
tree | 245251bdf75cd5d04df8acebf0952b7d30b1bc1b /src/gns | |
parent | a202cf2498161dae7e2060d7b8251303b1c06a38 (diff) | |
download | gnunet-0a99d7b72bd98fddabf16920a9e0129fbf8e0521.tar.gz gnunet-0a99d7b72bd98fddabf16920a9e0129fbf8e0521.zip |
-dos2unix
Diffstat (limited to 'src/gns')
-rw-r--r-- | src/gns/w32nsp.c | 1188 |
1 files changed, 594 insertions, 594 deletions
diff --git a/src/gns/w32nsp.c b/src/gns/w32nsp.c index 857facbcc..9b0d17dc7 100644 --- a/src/gns/w32nsp.c +++ b/src/gns/w32nsp.c | |||
@@ -1,23 +1,23 @@ | |||
1 | /* This code is partially based upon samples from the book | 1 | /* This code is partially based upon samples from the book |
2 | * "Network Programming For Microsoft Windows, 2Nd Edition". | 2 | * "Network Programming For Microsoft Windows, 2Nd Edition". |
3 | */ | 3 | */ |
4 | 4 | ||
5 | #define INITGUID | 5 | #define INITGUID |
6 | #include <windows.h> | 6 | #include <windows.h> |
7 | #include <nspapi.h> | 7 | #include <nspapi.h> |
8 | #include <stdint.h> | 8 | #include <stdint.h> |
9 | #include <ws2tcpip.h> | 9 | #include <ws2tcpip.h> |
10 | #include <ws2spi.h> | 10 | #include <ws2spi.h> |
11 | 11 | ||
12 | #if 1 | 12 | #if 1 |
13 | # define DEBUGLOG(s, ...) | 13 | # define DEBUGLOG(s, ...) |
14 | #endif | 14 | #endif |
15 | #if 0 | 15 | #if 0 |
16 | # define DEBUGLOG(s, ...) printf (s, ##__VA_ARGS__) | 16 | # define DEBUGLOG(s, ...) printf (s, ##__VA_ARGS__) |
17 | #endif | 17 | #endif |
18 | 18 | ||
19 | #define WINDOWS 1 | 19 | #define WINDOWS 1 |
20 | #define MINGW 1 | 20 | #define MINGW 1 |
21 | #ifndef __BYTE_ORDER | 21 | #ifndef __BYTE_ORDER |
22 | #ifdef _BYTE_ORDER | 22 | #ifdef _BYTE_ORDER |
23 | #define __BYTE_ORDER _BYTE_ORDER | 23 | #define __BYTE_ORDER _BYTE_ORDER |
@@ -45,19 +45,19 @@ | |||
45 | #endif | 45 | #endif |
46 | #endif | 46 | #endif |
47 | #endif | 47 | #endif |
48 | #include "gnunet_w32nsp_lib.h" | 48 | #include "gnunet_w32nsp_lib.h" |
49 | #include "w32resolver.h" | 49 | #include "w32resolver.h" |
50 | 50 | ||
51 | #define NSPAPI_VERSION_MAJOR 4 | 51 | #define NSPAPI_VERSION_MAJOR 4 |
52 | #define NSPAPI_VERSION_MINOR 4 | 52 | #define NSPAPI_VERSION_MINOR 4 |
53 | 53 | ||
54 | #define REPLY_LIFETIME 60*5 | 54 | #define REPLY_LIFETIME 60*5 |
55 | 55 | ||
56 | #define STATE_BEGIN 0x01 | 56 | #define STATE_BEGIN 0x01 |
57 | #define STATE_END 0x02 | 57 | #define STATE_END 0x02 |
58 | #define STATE_REPLY 0x04 | 58 | #define STATE_REPLY 0x04 |
59 | #define STATE_GHBN 0x08 | 59 | #define STATE_GHBN 0x08 |
60 | 60 | ||
61 | uint64_t | 61 | uint64_t |
62 | GNUNET_htonll (uint64_t n) | 62 | GNUNET_htonll (uint64_t n) |
63 | { | 63 | { |
@@ -69,84 +69,84 @@ GNUNET_htonll (uint64_t n) | |||
69 | #error byteorder undefined | 69 | #error byteorder undefined |
70 | #endif | 70 | #endif |
71 | } | 71 | } |
72 | 72 | ||
73 | CRITICAL_SECTION records_cs; | 73 | CRITICAL_SECTION records_cs; |
74 | 74 | ||
75 | struct record | 75 | struct record |
76 | { | 76 | { |
77 | SOCKET s; | 77 | SOCKET s; |
78 | DWORD flags; | 78 | DWORD flags; |
79 | uint8_t state; | 79 | uint8_t state; |
80 | char *buf; | 80 | char *buf; |
81 | wchar_t *name; | 81 | wchar_t *name; |
82 | }; | 82 | }; |
83 | 83 | ||
84 | static struct record *records = NULL; | 84 | static struct record *records = NULL; |
85 | static size_t records_len = 0; | 85 | static size_t records_len = 0; |
86 | static size_t records_size = 0; | 86 | static size_t records_size = 0; |
87 | 87 | ||
88 | int | 88 | int |
89 | resize_records () | 89 | resize_records () |
90 | { | 90 | { |
91 | size_t new_size = records_len > 0 ? records_len * 2 : 5; | 91 | size_t new_size = records_len > 0 ? records_len * 2 : 5; |
92 | struct record *new_records = malloc (new_size * sizeof (struct record)); | 92 | struct record *new_records = malloc (new_size * sizeof (struct record)); |
93 | if (new_records == NULL) | 93 | if (new_records == NULL) |
94 | { | 94 | { |
95 | SetLastError (WSA_NOT_ENOUGH_MEMORY); | 95 | SetLastError (WSA_NOT_ENOUGH_MEMORY); |
96 | return 0; | 96 | return 0; |
97 | } | 97 | } |
98 | memcpy (new_records, records, records_len * sizeof (struct record)); | 98 | memcpy (new_records, records, records_len * sizeof (struct record)); |
99 | memset (&new_records[records_len], 0, sizeof (struct record) * (new_size - records_len)); | 99 | memset (&new_records[records_len], 0, sizeof (struct record) * (new_size - records_len)); |
100 | records_size = new_size; | 100 | records_size = new_size; |
101 | free (records); | 101 | free (records); |
102 | records = new_records; | 102 | records = new_records; |
103 | return 1; | 103 | return 1; |
104 | } | 104 | } |
105 | 105 | ||
106 | int | 106 | int |
107 | add_record (SOCKET s, const wchar_t *name, DWORD flags) | 107 | add_record (SOCKET s, const wchar_t *name, DWORD flags) |
108 | { | 108 | { |
109 | int res = 1; | 109 | int res = 1; |
110 | int i; | 110 | int i; |
111 | int empty = -1; | 111 | int empty = -1; |
112 | //EnterCriticalSection (&records_cs); | 112 | //EnterCriticalSection (&records_cs); |
113 | for (i = 0; i < records_len; i++) | 113 | for (i = 0; i < records_len; i++) |
114 | if (records[i].state == 0) | 114 | if (records[i].state == 0) |
115 | break; | 115 | break; |
116 | empty = i; | 116 | empty = i; |
117 | if (i == records_len) | 117 | if (i == records_len) |
118 | { | 118 | { |
119 | res = resize_records (); | 119 | res = resize_records (); |
120 | if (res) | 120 | if (res) |
121 | empty = records_len++; | 121 | empty = records_len++; |
122 | } | 122 | } |
123 | if (res) | 123 | if (res) |
124 | { | 124 | { |
125 | struct record r; | 125 | struct record r; |
126 | r.s = s; | 126 | r.s = s; |
127 | r.flags = flags; | 127 | r.flags = flags; |
128 | r.name = (wchar_t *) name; | 128 | r.name = (wchar_t *) name; |
129 | r.state = 1; | 129 | r.state = 1; |
130 | r.buf = NULL; | 130 | r.buf = NULL; |
131 | if (name) | 131 | if (name) |
132 | r.name = wcsdup (name); | 132 | r.name = wcsdup (name); |
133 | records[empty] = r; | 133 | records[empty] = r; |
134 | } | 134 | } |
135 | //LeaveCriticalSection (&records_cs); | 135 | //LeaveCriticalSection (&records_cs); |
136 | return res; | 136 | return res; |
137 | } | 137 | } |
138 | 138 | ||
139 | void | 139 | void |
140 | free_record (int i) | 140 | free_record (int i) |
141 | { | 141 | { |
142 | if (records[i].name) | 142 | if (records[i].name) |
143 | free (records[i].name); | 143 | free (records[i].name); |
144 | records[i].state = 0; | 144 | records[i].state = 0; |
145 | } | 145 | } |
146 | 146 | ||
147 | /* These are not defined by mingw.org headers at the moment*/ | 147 | /* These are not defined by mingw.org headers at the moment*/ |
148 | typedef INT (WSPAPI *LPNSPIOCTL) (HANDLE,DWORD,LPVOID,DWORD,LPVOID,DWORD,LPDWORD,LPWSACOMPLETION,LPWSATHREADID); | 148 | typedef INT (WSPAPI *LPNSPIOCTL) (HANDLE,DWORD,LPVOID,DWORD,LPVOID,DWORD,LPDWORD,LPWSACOMPLETION,LPWSATHREADID); |
149 | typedef struct _NSP_ROUTINE_XP { | 149 | typedef struct _NSP_ROUTINE_XP { |
150 | DWORD cbSize; | 150 | DWORD cbSize; |
151 | DWORD dwMajorVersion; | 151 | DWORD dwMajorVersion; |
152 | DWORD dwMinorVersion; | 152 | DWORD dwMinorVersion; |
@@ -160,56 +160,56 @@ typedef struct _NSP_ROUTINE_XP { | |||
160 | LPNSPGETSERVICECLASSINFO NSPGetServiceClassInfo; | 160 | LPNSPGETSERVICECLASSINFO NSPGetServiceClassInfo; |
161 | LPNSPIOCTL NSPIoctl; | 161 | LPNSPIOCTL NSPIoctl; |
162 | } NSP_ROUTINE_XP, *PNSP_ROUTINE_XP, *LPNSP_ROUTINE_XP; | 162 | } NSP_ROUTINE_XP, *PNSP_ROUTINE_XP, *LPNSP_ROUTINE_XP; |
163 | 163 | ||
164 | static SOCKET | 164 | static SOCKET |
165 | connect_to_dns_resolver () | 165 | connect_to_dns_resolver () |
166 | { | 166 | { |
167 | struct sockaddr_in addr; | 167 | struct sockaddr_in addr; |
168 | SOCKET r; | 168 | SOCKET r; |
169 | int ret; | 169 | int ret; |
170 | 170 | ||
171 | r = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP); | 171 | r = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP); |
172 | if (INVALID_SOCKET == r) | 172 | if (INVALID_SOCKET == r) |
173 | { | 173 | { |
174 | SetLastError (16004); | 174 | SetLastError (16004); |
175 | return r; | 175 | return r; |
176 | } | 176 | } |
177 | 177 | ||
178 | addr.sin_family = AF_INET; | 178 | addr.sin_family = AF_INET; |
179 | addr.sin_port = htons (5353); /* TCP 5353 is not registered; UDP 5353 is */ | 179 | addr.sin_port = htons (5353); /* TCP 5353 is not registered; UDP 5353 is */ |
180 | addr.sin_addr.s_addr = inet_addr ("127.0.0.1"); | 180 | addr.sin_addr.s_addr = inet_addr ("127.0.0.1"); |
181 | 181 | ||
182 | ret = connect (r, (struct sockaddr *) &addr, sizeof (addr)); | 182 | ret = connect (r, (struct sockaddr *) &addr, sizeof (addr)); |
183 | if (SOCKET_ERROR == ret) | 183 | if (SOCKET_ERROR == ret) |
184 | { | 184 | { |
185 | DWORD err = GetLastError (); | 185 | DWORD err = GetLastError (); |
186 | closesocket (r); | 186 | closesocket (r); |
187 | SetLastError (err); | 187 | SetLastError (err); |
188 | SetLastError (16005); | 188 | SetLastError (16005); |
189 | r = INVALID_SOCKET; | 189 | r = INVALID_SOCKET; |
190 | } | 190 | } |
191 | return r; | 191 | return r; |
192 | } | 192 | } |
193 | 193 | ||
194 | static int | 194 | static int |
195 | send_name_to_ip_request (LPWSAQUERYSETW lpqsRestrictions, | 195 | send_name_to_ip_request (LPWSAQUERYSETW lpqsRestrictions, |
196 | LPWSASERVICECLASSINFOW lpServiceClassInfo, DWORD dwControlFlags, | 196 | LPWSASERVICECLASSINFOW lpServiceClassInfo, DWORD dwControlFlags, |
197 | SOCKET *resolver) | 197 | SOCKET *resolver) |
198 | { | 198 | { |
199 | struct GNUNET_W32RESOLVER_GetMessage *msg; | 199 | struct GNUNET_W32RESOLVER_GetMessage *msg; |
200 | int af4 = 0; | 200 | int af4 = 0; |
201 | int af6 = 0; | 201 | int af6 = 0; |
202 | char *buf; | 202 | char *buf; |
203 | int ret = 1; | 203 | int ret = 1; |
204 | int i; | 204 | int i; |
205 | uint32_t id; | 205 | uint32_t id; |
206 | size_t size = sizeof (struct GNUNET_W32RESOLVER_GetMessage); | 206 | size_t size = sizeof (struct GNUNET_W32RESOLVER_GetMessage); |
207 | size_t namelen = 0; | 207 | size_t namelen = 0; |
208 | if (lpqsRestrictions->lpszServiceInstanceName) | 208 | if (lpqsRestrictions->lpszServiceInstanceName) |
209 | namelen = sizeof (wchar_t) * (wcslen (lpqsRestrictions->lpszServiceInstanceName) + 1); | 209 | namelen = sizeof (wchar_t) * (wcslen (lpqsRestrictions->lpszServiceInstanceName) + 1); |
210 | size += namelen; | 210 | size += namelen; |
211 | buf = malloc (size); | 211 | buf = malloc (size); |
212 | msg = (struct GNUNET_W32RESOLVER_GetMessage *) buf; | 212 | msg = (struct GNUNET_W32RESOLVER_GetMessage *) buf; |
213 | msg->header.size = htons (size); | 213 | msg->header.size = htons (size); |
214 | msg->header.type = htons (GNUNET_MESSAGE_TYPE_W32RESOLVER_REQUEST); | 214 | msg->header.type = htons (GNUNET_MESSAGE_TYPE_W32RESOLVER_REQUEST); |
215 | if (lpqsRestrictions->dwNumberOfProtocols > 0) | 215 | if (lpqsRestrictions->dwNumberOfProtocols > 0) |
@@ -241,441 +241,441 @@ send_name_to_ip_request (LPWSAQUERYSETW lpqsRestrictions, | |||
241 | *resolver = connect_to_dns_resolver (); | 241 | *resolver = connect_to_dns_resolver (); |
242 | if (*resolver != INVALID_SOCKET) | 242 | if (*resolver != INVALID_SOCKET) |
243 | { | 243 | { |
244 | if (size != send (*resolver, buf, size, 0)) | 244 | if (size != send (*resolver, buf, size, 0)) |
245 | { | 245 | { |
246 | DWORD err = GetLastError (); | 246 | DWORD err = GetLastError (); |
247 | closesocket (*resolver); | 247 | closesocket (*resolver); |
248 | *resolver = INVALID_SOCKET; | 248 | *resolver = INVALID_SOCKET; |
249 | DEBUGLOG ("GNUNET_W32NSP_LookupServiceBegin: failed to send request: %lu\n", err); | 249 | DEBUGLOG ("GNUNET_W32NSP_LookupServiceBegin: failed to send request: %lu\n", err); |
250 | SetLastError (WSATRY_AGAIN); | 250 | SetLastError (WSATRY_AGAIN); |
251 | ret = 0; | 251 | ret = 0; |
252 | } | 252 | } |
253 | } | 253 | } |
254 | else | 254 | else |
255 | ret = 0; | 255 | ret = 0; |
256 | free (buf); | 256 | free (buf); |
257 | return ret; | 257 | return ret; |
258 | } | 258 | } |
259 | 259 | ||
260 | int WSPAPI | 260 | int WSPAPI |
261 | NSPCleanup (LPGUID lpProviderId) | 261 | NSPCleanup (LPGUID lpProviderId) |
262 | { | 262 | { |
263 | DEBUGLOG ("NSPCleanup\n"); | 263 | DEBUGLOG ("NSPCleanup\n"); |
264 | if (IsEqualGUID (lpProviderId, &GNUNET_NAMESPACE_PROVIDER_DNS)) | 264 | if (IsEqualGUID (lpProviderId, &GNUNET_NAMESPACE_PROVIDER_DNS)) |
265 | { | 265 | { |
266 | return NO_ERROR; | 266 | return NO_ERROR; |
267 | } | 267 | } |
268 | SetLastError (WSAEINVALIDPROVIDER); | 268 | SetLastError (WSAEINVALIDPROVIDER); |
269 | return SOCKET_ERROR; | 269 | return SOCKET_ERROR; |
270 | } | 270 | } |
271 | 271 | ||
272 | BOOL WINAPI | 272 | BOOL WINAPI |
273 | DllMain (HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved) | 273 | DllMain (HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved) |
274 | { | 274 | { |
275 | switch (fdwReason) | 275 | switch (fdwReason) |
276 | { | 276 | { |
277 | case DLL_PROCESS_ATTACH: | 277 | case DLL_PROCESS_ATTACH: |
278 | if (!InitializeCriticalSectionAndSpinCount (&records_cs, 0x00000400)) | 278 | if (!InitializeCriticalSectionAndSpinCount (&records_cs, 0x00000400)) |
279 | { | 279 | { |
280 | return FALSE; | 280 | return FALSE; |
281 | } | 281 | } |
282 | break; | 282 | break; |
283 | case DLL_THREAD_ATTACH: | 283 | case DLL_THREAD_ATTACH: |
284 | break; | 284 | break; |
285 | case DLL_THREAD_DETACH: | 285 | case DLL_THREAD_DETACH: |
286 | break; | 286 | break; |
287 | case DLL_PROCESS_DETACH: | 287 | case DLL_PROCESS_DETACH: |
288 | DeleteCriticalSection (&records_cs); | 288 | DeleteCriticalSection (&records_cs); |
289 | break; | 289 | break; |
290 | } | 290 | } |
291 | return TRUE; | 291 | return TRUE; |
292 | } | 292 | } |
293 | 293 | ||
294 | 294 | ||
295 | 295 | ||
296 | 296 | ||
297 | int WSPAPI | 297 | int WSPAPI |
298 | GNUNET_W32NSP_LookupServiceBegin (LPGUID lpProviderId, LPWSAQUERYSETW lpqsRestrictions, | 298 | GNUNET_W32NSP_LookupServiceBegin (LPGUID lpProviderId, LPWSAQUERYSETW lpqsRestrictions, |
299 | LPWSASERVICECLASSINFOW lpServiceClassInfo, DWORD dwControlFlags, | 299 | LPWSASERVICECLASSINFOW lpServiceClassInfo, DWORD dwControlFlags, |
300 | LPHANDLE lphLookup) | 300 | LPHANDLE lphLookup) |
301 | { | 301 | { |
302 | DEBUGLOG ("GNUNET_W32NSP_LookupServiceBegin\n"); | 302 | DEBUGLOG ("GNUNET_W32NSP_LookupServiceBegin\n"); |
303 | if (IsEqualGUID (lpProviderId, &GNUNET_NAMESPACE_PROVIDER_DNS)) | 303 | if (IsEqualGUID (lpProviderId, &GNUNET_NAMESPACE_PROVIDER_DNS)) |
304 | { | 304 | { |
305 | SOCKET s; | 305 | SOCKET s; |
306 | if (lpqsRestrictions->dwNameSpace != NS_DNS && lpqsRestrictions->dwNameSpace != NS_ALL) | 306 | if (lpqsRestrictions->dwNameSpace != NS_DNS && lpqsRestrictions->dwNameSpace != NS_ALL) |
307 | { | 307 | { |
308 | DEBUGLOG ("GNUNET_W32NSP_LookupServiceBegin: wrong namespace\n"); | 308 | DEBUGLOG ("GNUNET_W32NSP_LookupServiceBegin: wrong namespace\n"); |
309 | SetLastError (WSANO_DATA); | 309 | SetLastError (WSANO_DATA); |
310 | return SOCKET_ERROR; | 310 | return SOCKET_ERROR; |
311 | } | 311 | } |
312 | if (lpqsRestrictions->lpszServiceInstanceName != NULL) | 312 | if (lpqsRestrictions->lpszServiceInstanceName != NULL) |
313 | { | 313 | { |
314 | wchar_t *s = lpqsRestrictions->lpszServiceInstanceName; | 314 | wchar_t *s = lpqsRestrictions->lpszServiceInstanceName; |
315 | size_t len = wcslen (s); | 315 | size_t len = wcslen (s); |
316 | if (len >= 4 && wcscmp (&s[len - 4], L"zkey") == 0) | 316 | if (len >= 4 && wcscmp (&s[len - 4], L"zkey") == 0) |
317 | { | 317 | { |
318 | } | 318 | } |
319 | else if (len >= 6 && wcscmp (&s[len - 6], L"gnunet") == 0) | 319 | else if (len >= 6 && wcscmp (&s[len - 6], L"gnunet") == 0) |
320 | { | 320 | { |
321 | } | 321 | } |
322 | else | 322 | else |
323 | { | 323 | { |
324 | DEBUGLOG ("GNUNET_W32NSP_LookupServiceBegin: unsupported TLD\n"); | 324 | DEBUGLOG ("GNUNET_W32NSP_LookupServiceBegin: unsupported TLD\n"); |
325 | SetLastError (WSANO_DATA); | 325 | SetLastError (WSANO_DATA); |
326 | return SOCKET_ERROR; | 326 | return SOCKET_ERROR; |
327 | } | 327 | } |
328 | } | 328 | } |
329 | 329 | ||
330 | if (send_name_to_ip_request (lpqsRestrictions, | 330 | if (send_name_to_ip_request (lpqsRestrictions, |
331 | lpServiceClassInfo, dwControlFlags, &s)) | 331 | lpServiceClassInfo, dwControlFlags, &s)) |
332 | { | 332 | { |
333 | if (!(add_record (s, lpqsRestrictions->lpszServiceInstanceName, dwControlFlags))) | 333 | if (!(add_record (s, lpqsRestrictions->lpszServiceInstanceName, dwControlFlags))) |
334 | { | 334 | { |
335 | DWORD err = GetLastError (); | 335 | DWORD err = GetLastError (); |
336 | DEBUGLOG ("GNUNET_W32NSP_LookupServiceBegin: failed to add a record\n"); | 336 | DEBUGLOG ("GNUNET_W32NSP_LookupServiceBegin: failed to add a record\n"); |
337 | closesocket (s); | 337 | closesocket (s); |
338 | SetLastError (err); | 338 | SetLastError (err); |
339 | return SOCKET_ERROR; | 339 | return SOCKET_ERROR; |
340 | } | 340 | } |
341 | *lphLookup = (HANDLE) s; | 341 | *lphLookup = (HANDLE) s; |
342 | DEBUGLOG ("GNUNET_W32NSP_LookupServiceBegin: OK (%lu)\n", GetLastError ()); | 342 | DEBUGLOG ("GNUNET_W32NSP_LookupServiceBegin: OK (%lu)\n", GetLastError ()); |
343 | return NO_ERROR; | 343 | return NO_ERROR; |
344 | } | 344 | } |
345 | return SOCKET_ERROR; | 345 | return SOCKET_ERROR; |
346 | } | 346 | } |
347 | DEBUGLOG ("GNUNET_W32NSP_LookupServiceBegin: wrong provider\n"); | 347 | DEBUGLOG ("GNUNET_W32NSP_LookupServiceBegin: wrong provider\n"); |
348 | SetLastError (WSAEINVALIDPROVIDER); | 348 | SetLastError (WSAEINVALIDPROVIDER); |
349 | return SOCKET_ERROR; | 349 | return SOCKET_ERROR; |
350 | } | 350 | } |
351 | 351 | ||
352 | #define UnmarshallPtr(ptr, ptrtype, base) \ | 352 | #define UnmarshallPtr(ptr, ptrtype, base) \ |
353 | if (ptr) \ | 353 | if (ptr) \ |
354 | ptr = (ptrtype *) (base + (uintptr_t) ptr) | 354 | ptr = (ptrtype *) (base + (uintptr_t) ptr) |
355 | 355 | ||
356 | void | 356 | void |
357 | UnmarshallWSAQUERYSETW (LPWSAQUERYSETW req) | 357 | UnmarshallWSAQUERYSETW (LPWSAQUERYSETW req) |
358 | { | 358 | { |
359 | int i; | 359 | int i; |
360 | char *base = (char *) req; | 360 | char *base = (char *) req; |
361 | UnmarshallPtr (req->lpszServiceInstanceName, wchar_t, base); | 361 | UnmarshallPtr (req->lpszServiceInstanceName, wchar_t, base); |
362 | UnmarshallPtr (req->lpServiceClassId, GUID, base); | 362 | UnmarshallPtr (req->lpServiceClassId, GUID, base); |
363 | UnmarshallPtr (req->lpVersion, WSAVERSION, base); | 363 | UnmarshallPtr (req->lpVersion, WSAVERSION, base); |
364 | UnmarshallPtr (req->lpszComment, wchar_t, base); | 364 | UnmarshallPtr (req->lpszComment, wchar_t, base); |
365 | UnmarshallPtr (req->lpNSProviderId, GUID, base); | 365 | UnmarshallPtr (req->lpNSProviderId, GUID, base); |
366 | UnmarshallPtr (req->lpszContext, wchar_t, base); | 366 | UnmarshallPtr (req->lpszContext, wchar_t, base); |
367 | UnmarshallPtr (req->lpafpProtocols, AFPROTOCOLS, base); | 367 | UnmarshallPtr (req->lpafpProtocols, AFPROTOCOLS, base); |
368 | UnmarshallPtr (req->lpszQueryString, wchar_t, base); | 368 | UnmarshallPtr (req->lpszQueryString, wchar_t, base); |
369 | UnmarshallPtr (req->lpcsaBuffer, CSADDR_INFO, base); | 369 | UnmarshallPtr (req->lpcsaBuffer, CSADDR_INFO, base); |
370 | for (i = 0; i < req->dwNumberOfCsAddrs; i++) | 370 | for (i = 0; i < req->dwNumberOfCsAddrs; i++) |
371 | { | 371 | { |
372 | UnmarshallPtr (req->lpcsaBuffer[i].LocalAddr.lpSockaddr, SOCKADDR, base); | 372 | UnmarshallPtr (req->lpcsaBuffer[i].LocalAddr.lpSockaddr, SOCKADDR, base); |
373 | UnmarshallPtr (req->lpcsaBuffer[i].RemoteAddr.lpSockaddr, SOCKADDR, base); | 373 | UnmarshallPtr (req->lpcsaBuffer[i].RemoteAddr.lpSockaddr, SOCKADDR, base); |
374 | } | 374 | } |
375 | UnmarshallPtr (req->lpBlob, BLOB, base); | 375 | UnmarshallPtr (req->lpBlob, BLOB, base); |
376 | if (req->lpBlob) | 376 | if (req->lpBlob) |
377 | UnmarshallPtr (req->lpBlob->pBlobData, BYTE, base); | 377 | UnmarshallPtr (req->lpBlob->pBlobData, BYTE, base); |
378 | } | 378 | } |
379 | 379 | ||
380 | int WSAAPI | 380 | int WSAAPI |
381 | GNUNET_W32NSP_LookupServiceNext (HANDLE hLookup, DWORD dwControlFlags, | 381 | GNUNET_W32NSP_LookupServiceNext (HANDLE hLookup, DWORD dwControlFlags, |
382 | LPDWORD lpdwBufferLength, LPWSAQUERYSET lpqsResults) | 382 | LPDWORD lpdwBufferLength, LPWSAQUERYSET lpqsResults) |
383 | { | 383 | { |
384 | DWORD effective_flags; | 384 | DWORD effective_flags; |
385 | int i; | 385 | int i; |
386 | struct GNUNET_MessageHeader header = {0, 0}; | 386 | struct GNUNET_MessageHeader header = {0, 0}; |
387 | int rec = -1; | 387 | int rec = -1; |
388 | int rc; | 388 | int rc; |
389 | int to_receive; | 389 | int to_receive; |
390 | int t; | 390 | int t; |
391 | char *buf; | 391 | char *buf; |
392 | 392 | ||
393 | DEBUGLOG ("GNUNET_W32NSP_LookupServiceNext\n"); | 393 | DEBUGLOG ("GNUNET_W32NSP_LookupServiceNext\n"); |
394 | //EnterCriticalSection (&records_cs); | 394 | //EnterCriticalSection (&records_cs); |
395 | for (i = 0; i < records_len; i++) | 395 | for (i = 0; i < records_len; i++) |
396 | { | 396 | { |
397 | if (records[i].s == (SOCKET) hLookup) | 397 | if (records[i].s == (SOCKET) hLookup) |
398 | { | 398 | { |
399 | rec = i; | 399 | rec = i; |
400 | break; | 400 | break; |
401 | } | 401 | } |
402 | } | 402 | } |
403 | if (rec == -1) | 403 | if (rec == -1) |
404 | { | 404 | { |
405 | DEBUGLOG ("GNUNET_W32NSP_LookupServiceNext: invalid handle\n"); | 405 | DEBUGLOG ("GNUNET_W32NSP_LookupServiceNext: invalid handle\n"); |
406 | SetLastError (WSA_INVALID_HANDLE); | 406 | SetLastError (WSA_INVALID_HANDLE); |
407 | //LeaveCriticalSection (&records_cs); | 407 | //LeaveCriticalSection (&records_cs); |
408 | return SOCKET_ERROR; | 408 | return SOCKET_ERROR; |
409 | } | 409 | } |
410 | if (records[rec].state & 4) | 410 | if (records[rec].state & 4) |
411 | { | 411 | { |
412 | DEBUGLOG ("GNUNET_W32NSP_LookupServiceNext: session is closed\n"); | 412 | DEBUGLOG ("GNUNET_W32NSP_LookupServiceNext: session is closed\n"); |
413 | SetLastError (WSA_E_NO_MORE); | 413 | SetLastError (WSA_E_NO_MORE); |
414 | //LeaveCriticalSection (&records_cs); | 414 | //LeaveCriticalSection (&records_cs); |
415 | return SOCKET_ERROR; | 415 | return SOCKET_ERROR; |
416 | } | 416 | } |
417 | effective_flags = dwControlFlags & records[rec].flags; | 417 | effective_flags = dwControlFlags & records[rec].flags; |
418 | if (records[rec].buf) | 418 | if (records[rec].buf) |
419 | { | 419 | { |
420 | header = *((struct GNUNET_MessageHeader *) records[rec].buf); | 420 | header = *((struct GNUNET_MessageHeader *) records[rec].buf); |
421 | if (dwControlFlags & LUP_FLUSHCACHE) | 421 | if (dwControlFlags & LUP_FLUSHCACHE) |
422 | { | 422 | { |
423 | free (records[rec].buf); | 423 | free (records[rec].buf); |
424 | records[rec].buf = NULL; | 424 | records[rec].buf = NULL; |
425 | } | 425 | } |
426 | else | 426 | else |
427 | { | 427 | { |
428 | if (*lpdwBufferLength < header.size - sizeof (struct GNUNET_W32RESOLVER_GetMessage)) | 428 | if (*lpdwBufferLength < header.size - sizeof (struct GNUNET_W32RESOLVER_GetMessage)) |
429 | { | 429 | { |
430 | DEBUGLOG ("GNUNET_W32NSP_LookupServiceNext: client buffer is too small\n"); | 430 | DEBUGLOG ("GNUNET_W32NSP_LookupServiceNext: client buffer is too small\n"); |
431 | SetLastError (WSAEFAULT); | 431 | SetLastError (WSAEFAULT); |
432 | //LeaveCriticalSection (&records_cs); | 432 | //LeaveCriticalSection (&records_cs); |
433 | return SOCKET_ERROR; | 433 | return SOCKET_ERROR; |
434 | } | 434 | } |
435 | memcpy (lpqsResults, &((struct GNUNET_W32RESOLVER_GetMessage *)records[rec].buf)[1], header.size - sizeof (struct GNUNET_W32RESOLVER_GetMessage)); | 435 | memcpy (lpqsResults, &((struct GNUNET_W32RESOLVER_GetMessage *)records[rec].buf)[1], header.size - sizeof (struct GNUNET_W32RESOLVER_GetMessage)); |
436 | free (records[rec].buf); | 436 | free (records[rec].buf); |
437 | records[rec].buf = NULL; | 437 | records[rec].buf = NULL; |
438 | //LeaveCriticalSection (&records_cs); | 438 | //LeaveCriticalSection (&records_cs); |
439 | UnmarshallWSAQUERYSETW ((LPWSAQUERYSETW) lpqsResults); | 439 | UnmarshallWSAQUERYSETW ((LPWSAQUERYSETW) lpqsResults); |
440 | DEBUGLOG ("GNUNET_W32NSP_LookupServiceNext: OK (from buffer)\n"); | 440 | DEBUGLOG ("GNUNET_W32NSP_LookupServiceNext: OK (from buffer)\n"); |
441 | return NO_ERROR; | 441 | return NO_ERROR; |
442 | } | 442 | } |
443 | } | 443 | } |
444 | records[rec].state |= 8; | 444 | records[rec].state |= 8; |
445 | //LeaveCriticalSection (&records_cs); | 445 | //LeaveCriticalSection (&records_cs); |
446 | to_receive = sizeof (header); | 446 | to_receive = sizeof (header); |
447 | rc = 0; | 447 | rc = 0; |
448 | while (to_receive > 0) | 448 | while (to_receive > 0) |
449 | { | 449 | { |
450 | t = recv ((SOCKET) hLookup, &((char *) &header)[rc], to_receive, 0); | 450 | t = recv ((SOCKET) hLookup, &((char *) &header)[rc], to_receive, 0); |
451 | if (t > 0) | 451 | if (t > 0) |
452 | { | 452 | { |
453 | rc += t; | 453 | rc += t; |
454 | to_receive -= t; | 454 | to_receive -= t; |
455 | } | 455 | } |
456 | else | 456 | else |
457 | break; | 457 | break; |
458 | } | 458 | } |
459 | //EnterCriticalSection (&records_cs); | 459 | //EnterCriticalSection (&records_cs); |
460 | records[rec].state &= ~8; | 460 | records[rec].state &= ~8; |
461 | if (rc != sizeof (header)) | 461 | if (rc != sizeof (header)) |
462 | { | 462 | { |
463 | if (records[rec].state & 2) | 463 | if (records[rec].state & 2) |
464 | { | 464 | { |
465 | DEBUGLOG ("GNUNET_W32NSP_LookupServiceNext: call cancelled\n"); | 465 | DEBUGLOG ("GNUNET_W32NSP_LookupServiceNext: call cancelled\n"); |
466 | SetLastError (WSA_E_CANCELLED); | 466 | SetLastError (WSA_E_CANCELLED); |
467 | } | 467 | } |
468 | else | 468 | else |
469 | { | 469 | { |
470 | DEBUGLOG ("GNUNET_W32NSP_LookupServiceNext: failed to receive enough data\n"); | 470 | DEBUGLOG ("GNUNET_W32NSP_LookupServiceNext: failed to receive enough data\n"); |
471 | SetLastError (WSA_E_NO_MORE); | 471 | SetLastError (WSA_E_NO_MORE); |
472 | } | 472 | } |
473 | records[rec].state |= 4; | 473 | records[rec].state |= 4; |
474 | //LeaveCriticalSection (&records_cs); | 474 | //LeaveCriticalSection (&records_cs); |
475 | return SOCKET_ERROR; | 475 | return SOCKET_ERROR; |
476 | } | 476 | } |
477 | records[rec].state &= ~8; | 477 | records[rec].state &= ~8; |
478 | header.type = ntohs (header.type); | 478 | header.type = ntohs (header.type); |
479 | header.size = ntohs (header.size); | 479 | header.size = ntohs (header.size); |
480 | if (header.type != GNUNET_MESSAGE_TYPE_W32RESOLVER_RESPONSE || | 480 | if (header.type != GNUNET_MESSAGE_TYPE_W32RESOLVER_RESPONSE || |
481 | (header.type == GNUNET_MESSAGE_TYPE_W32RESOLVER_RESPONSE && | 481 | (header.type == GNUNET_MESSAGE_TYPE_W32RESOLVER_RESPONSE && |
482 | header.size == sizeof (header))) | 482 | header.size == sizeof (header))) |
483 | { | 483 | { |
484 | records[rec].state |= 4; | 484 | records[rec].state |= 4; |
485 | DEBUGLOG ("GNUNET_W32NSP_LookupServiceNext: header is wrong or type is wrong or no data\n"); | 485 | DEBUGLOG ("GNUNET_W32NSP_LookupServiceNext: header is wrong or type is wrong or no data\n"); |
486 | //LeaveCriticalSection (&records_cs); | 486 | //LeaveCriticalSection (&records_cs); |
487 | SetLastError (WSA_E_NO_MORE); | 487 | SetLastError (WSA_E_NO_MORE); |
488 | return SOCKET_ERROR; | 488 | return SOCKET_ERROR; |
489 | } | 489 | } |
490 | buf = malloc (header.size); | 490 | buf = malloc (header.size); |
491 | if (buf == NULL) | 491 | if (buf == NULL) |
492 | { | 492 | { |
493 | records[rec].state |= 4; | 493 | records[rec].state |= 4; |
494 | DEBUGLOG ("GNUNET_W32NSP_LookupServiceNext: malloc() failed\n"); | 494 | DEBUGLOG ("GNUNET_W32NSP_LookupServiceNext: malloc() failed\n"); |
495 | //LeaveCriticalSection (&records_cs); | 495 | //LeaveCriticalSection (&records_cs); |
496 | SetLastError (WSA_E_NO_MORE); | 496 | SetLastError (WSA_E_NO_MORE); |
497 | return SOCKET_ERROR; | 497 | return SOCKET_ERROR; |
498 | } | 498 | } |
499 | records[rec].state |= 8; | 499 | records[rec].state |= 8; |
500 | //LeaveCriticalSection (&records_cs); | 500 | //LeaveCriticalSection (&records_cs); |
501 | memcpy (buf, &header, sizeof (header)); | 501 | memcpy (buf, &header, sizeof (header)); |
502 | to_receive = header.size - sizeof (header); | 502 | to_receive = header.size - sizeof (header); |
503 | rc = 0; | 503 | rc = 0; |
504 | while (to_receive > 0) | 504 | while (to_receive > 0) |
505 | { | 505 | { |
506 | t = recv ((SOCKET) hLookup, &((char *) &((struct GNUNET_MessageHeader *) buf)[1])[rc], to_receive, 0); | 506 | t = recv ((SOCKET) hLookup, &((char *) &((struct GNUNET_MessageHeader *) buf)[1])[rc], to_receive, 0); |
507 | if (t > 0) | 507 | if (t > 0) |
508 | { | 508 | { |
509 | rc += t; | 509 | rc += t; |
510 | to_receive -= t; | 510 | to_receive -= t; |
511 | } | 511 | } |
512 | else | 512 | else |
513 | break; | 513 | break; |
514 | } | 514 | } |
515 | //EnterCriticalSection (&records_cs); | 515 | //EnterCriticalSection (&records_cs); |
516 | records[rec].state &= ~8; | 516 | records[rec].state &= ~8; |
517 | if (rc != header.size - sizeof (header)) | 517 | if (rc != header.size - sizeof (header)) |
518 | { | 518 | { |
519 | free (buf); | 519 | free (buf); |
520 | if (records[rec].state & 2) | 520 | if (records[rec].state & 2) |
521 | { | 521 | { |
522 | DEBUGLOG ("GNUNET_W32NSP_LookupServiceNext: call cancelled\n"); | 522 | DEBUGLOG ("GNUNET_W32NSP_LookupServiceNext: call cancelled\n"); |
523 | SetLastError (WSA_E_CANCELLED); | 523 | SetLastError (WSA_E_CANCELLED); |
524 | } | 524 | } |
525 | else | 525 | else |
526 | { | 526 | { |
527 | DEBUGLOG ("GNUNET_W32NSP_LookupServiceNext: failed to receive enough data\n"); | 527 | DEBUGLOG ("GNUNET_W32NSP_LookupServiceNext: failed to receive enough data\n"); |
528 | SetLastError (WSA_E_NO_MORE); | 528 | SetLastError (WSA_E_NO_MORE); |
529 | } | 529 | } |
530 | records[rec].state |= 4; | 530 | records[rec].state |= 4; |
531 | //LeaveCriticalSection (&records_cs); | 531 | //LeaveCriticalSection (&records_cs); |
532 | return SOCKET_ERROR; | 532 | return SOCKET_ERROR; |
533 | } | 533 | } |
534 | if (*lpdwBufferLength < header.size - sizeof (struct GNUNET_W32RESOLVER_GetMessage)) | 534 | if (*lpdwBufferLength < header.size - sizeof (struct GNUNET_W32RESOLVER_GetMessage)) |
535 | { | 535 | { |
536 | DEBUGLOG ("GNUNET_W32NSP_LookupServiceNext: client buffer is too small\n"); | 536 | DEBUGLOG ("GNUNET_W32NSP_LookupServiceNext: client buffer is too small\n"); |
537 | SetLastError (WSAEFAULT); | 537 | SetLastError (WSAEFAULT); |
538 | records[rec].buf = buf; | 538 | records[rec].buf = buf; |
539 | //LeaveCriticalSection (&records_cs); | 539 | //LeaveCriticalSection (&records_cs); |
540 | return SOCKET_ERROR; | 540 | return SOCKET_ERROR; |
541 | } | 541 | } |
542 | //LeaveCriticalSection (&records_cs); | 542 | //LeaveCriticalSection (&records_cs); |
543 | memcpy (lpqsResults, &((struct GNUNET_W32RESOLVER_GetMessage *)buf)[1], header.size - sizeof (struct GNUNET_W32RESOLVER_GetMessage)); | 543 | memcpy (lpqsResults, &((struct GNUNET_W32RESOLVER_GetMessage *)buf)[1], header.size - sizeof (struct GNUNET_W32RESOLVER_GetMessage)); |
544 | free (buf); | 544 | free (buf); |
545 | DEBUGLOG ("GNUNET_W32NSP_LookupServiceNext: OK\n"); | 545 | DEBUGLOG ("GNUNET_W32NSP_LookupServiceNext: OK\n"); |
546 | UnmarshallWSAQUERYSETW ((LPWSAQUERYSETW) lpqsResults); | 546 | UnmarshallWSAQUERYSETW ((LPWSAQUERYSETW) lpqsResults); |
547 | DEBUGLOG ("GNUNET_W32NSP_LookupServiceNext: returning (%lu)\n", GetLastError ()); | 547 | DEBUGLOG ("GNUNET_W32NSP_LookupServiceNext: returning (%lu)\n", GetLastError ()); |
548 | return NO_ERROR; | 548 | return NO_ERROR; |
549 | } | 549 | } |
550 | 550 | ||
551 | int WSPAPI | 551 | int WSPAPI |
552 | GNUNET_W32NSP_LookupServiceEnd (HANDLE hLookup) | 552 | GNUNET_W32NSP_LookupServiceEnd (HANDLE hLookup) |
553 | { | 553 | { |
554 | DWORD effective_flags; | 554 | DWORD effective_flags; |
555 | int i; | 555 | int i; |
556 | struct GNUNET_MessageHeader header = {0, 0}; | 556 | struct GNUNET_MessageHeader header = {0, 0}; |
557 | int rec = -1; | 557 | int rec = -1; |
558 | int rc; | 558 | int rc; |
559 | char *buf; | 559 | char *buf; |
560 | 560 | ||
561 | DEBUGLOG ("GNUNET_W32NSP_LookupServiceEnd\n"); | 561 | DEBUGLOG ("GNUNET_W32NSP_LookupServiceEnd\n"); |
562 | //EnterCriticalSection (&records_cs); | 562 | //EnterCriticalSection (&records_cs); |
563 | for (i = 0; i < records_len; i++) | 563 | for (i = 0; i < records_len; i++) |
564 | { | 564 | { |
565 | if (records[i].s == (SOCKET) hLookup) | 565 | if (records[i].s == (SOCKET) hLookup) |
566 | { | 566 | { |
567 | rec = i; | 567 | rec = i; |
568 | break; | 568 | break; |
569 | } | 569 | } |
570 | } | 570 | } |
571 | if (rec == -1) | 571 | if (rec == -1) |
572 | { | 572 | { |
573 | SetLastError (WSA_INVALID_HANDLE); | 573 | SetLastError (WSA_INVALID_HANDLE); |
574 | //LeaveCriticalSection (&records_cs); | 574 | //LeaveCriticalSection (&records_cs); |
575 | DEBUGLOG ("GNUNET_W32NSP_LookupServiceEnd: invalid handle\n"); | 575 | DEBUGLOG ("GNUNET_W32NSP_LookupServiceEnd: invalid handle\n"); |
576 | return SOCKET_ERROR; | 576 | return SOCKET_ERROR; |
577 | } | 577 | } |
578 | records[rec].state |= 2; | 578 | records[rec].state |= 2; |
579 | closesocket (records[rec].s); | 579 | closesocket (records[rec].s); |
580 | while (records[rec].state & 8) | 580 | while (records[rec].state & 8) |
581 | { | 581 | { |
582 | //LeaveCriticalSection (&records_cs); | 582 | //LeaveCriticalSection (&records_cs); |
583 | Sleep (10); | 583 | Sleep (10); |
584 | //EnterCriticalSection (&records_cs); | 584 | //EnterCriticalSection (&records_cs); |
585 | } | 585 | } |
586 | if (records[rec].buf) | 586 | if (records[rec].buf) |
587 | free (records[rec].buf); | 587 | free (records[rec].buf); |
588 | records[rec].buf = NULL; | 588 | records[rec].buf = NULL; |
589 | records[rec].state = 0; | 589 | records[rec].state = 0; |
590 | if (records[rec].name) | 590 | if (records[rec].name) |
591 | free (records[rec].name); | 591 | free (records[rec].name); |
592 | //LeaveCriticalSection (&records_cs); | 592 | //LeaveCriticalSection (&records_cs); |
593 | DEBUGLOG ("GNUNET_W32NSP_LookupServiceEnd: OK\n"); | 593 | DEBUGLOG ("GNUNET_W32NSP_LookupServiceEnd: OK\n"); |
594 | return NO_ERROR; | 594 | return NO_ERROR; |
595 | } | 595 | } |
596 | 596 | ||
597 | int WSAAPI | 597 | int WSAAPI |
598 | GNUNET_W32NSP_SetService (LPGUID lpProviderId, | 598 | GNUNET_W32NSP_SetService (LPGUID lpProviderId, |
599 | LPWSASERVICECLASSINFOW lpServiceClassInfo, LPWSAQUERYSETW lpqsRegInfo, | 599 | LPWSASERVICECLASSINFOW lpServiceClassInfo, LPWSAQUERYSETW lpqsRegInfo, |
600 | WSAESETSERVICEOP essOperation, DWORD dwControlFlags) | 600 | WSAESETSERVICEOP essOperation, DWORD dwControlFlags) |
601 | { | 601 | { |
602 | DEBUGLOG ("GNUNET_W32NSP_SetService\n"); | 602 | DEBUGLOG ("GNUNET_W32NSP_SetService\n"); |
603 | SetLastError (WSAEOPNOTSUPP); | 603 | SetLastError (WSAEOPNOTSUPP); |
604 | return SOCKET_ERROR; | 604 | return SOCKET_ERROR; |
605 | } | 605 | } |
606 | 606 | ||
607 | int WSAAPI | 607 | int WSAAPI |
608 | GNUNET_W32NSP_InstallServiceClass (LPGUID lpProviderId, | 608 | GNUNET_W32NSP_InstallServiceClass (LPGUID lpProviderId, |
609 | LPWSASERVICECLASSINFOW lpServiceClassInfo) | 609 | LPWSASERVICECLASSINFOW lpServiceClassInfo) |
610 | { | 610 | { |
611 | DEBUGLOG ("GNUNET_W32NSP_InstallServiceClass\n"); | 611 | DEBUGLOG ("GNUNET_W32NSP_InstallServiceClass\n"); |
612 | SetLastError (WSAEOPNOTSUPP); | 612 | SetLastError (WSAEOPNOTSUPP); |
613 | return SOCKET_ERROR; | 613 | return SOCKET_ERROR; |
614 | } | 614 | } |
615 | 615 | ||
616 | 616 | ||
617 | int WSAAPI | 617 | int WSAAPI |
618 | GNUNET_W32NSP_RemoveServiceClass (LPGUID lpProviderId, LPGUID lpServiceClassId) | 618 | GNUNET_W32NSP_RemoveServiceClass (LPGUID lpProviderId, LPGUID lpServiceClassId) |
619 | { | 619 | { |
620 | DEBUGLOG ("GNUNET_W32NSP_RemoveServiceClass\n"); | 620 | DEBUGLOG ("GNUNET_W32NSP_RemoveServiceClass\n"); |
621 | SetLastError (WSAEOPNOTSUPP); | 621 | SetLastError (WSAEOPNOTSUPP); |
622 | return SOCKET_ERROR; | 622 | return SOCKET_ERROR; |
623 | } | 623 | } |
624 | 624 | ||
625 | int WSAAPI | 625 | int WSAAPI |
626 | GNUNET_W32NSP_GetServiceClassInfo (LPGUID lpProviderId, LPDWORD lpdwBufSize, | 626 | GNUNET_W32NSP_GetServiceClassInfo (LPGUID lpProviderId, LPDWORD lpdwBufSize, |
627 | LPWSASERVICECLASSINFOW lpServiceClassInfo) | 627 | LPWSASERVICECLASSINFOW lpServiceClassInfo) |
628 | { | 628 | { |
629 | DEBUGLOG ("GNUNET_W32NSP_GetServiceClassInfo\n"); | 629 | DEBUGLOG ("GNUNET_W32NSP_GetServiceClassInfo\n"); |
630 | SetLastError (WSAEOPNOTSUPP); | 630 | SetLastError (WSAEOPNOTSUPP); |
631 | return SOCKET_ERROR; | 631 | return SOCKET_ERROR; |
632 | } | 632 | } |
633 | 633 | ||
634 | int WSAAPI | 634 | int WSAAPI |
635 | GNUNET_W32NSP_Ioctl (HANDLE hLookup, DWORD dwControlCode, LPVOID lpvInBuffer, | 635 | GNUNET_W32NSP_Ioctl (HANDLE hLookup, DWORD dwControlCode, LPVOID lpvInBuffer, |
636 | DWORD cbInBuffer, LPVOID lpvOutBuffer, DWORD cbOutBuffer, | 636 | DWORD cbInBuffer, LPVOID lpvOutBuffer, DWORD cbOutBuffer, |
637 | LPDWORD lpcbBytesReturned, LPWSACOMPLETION lpCompletion, | 637 | LPDWORD lpcbBytesReturned, LPWSACOMPLETION lpCompletion, |
638 | LPWSATHREADID lpThreadId) | 638 | LPWSATHREADID lpThreadId) |
639 | { | 639 | { |
640 | DEBUGLOG ("GNUNET_W32NSP_Ioctl\n"); | 640 | DEBUGLOG ("GNUNET_W32NSP_Ioctl\n"); |
641 | SetLastError (WSAEOPNOTSUPP); | 641 | SetLastError (WSAEOPNOTSUPP); |
642 | return SOCKET_ERROR; | 642 | return SOCKET_ERROR; |
643 | } | 643 | } |
644 | 644 | ||
645 | /** | 645 | /** |
646 | * This function is called by Winsock to hook up our provider. | 646 | * This function is called by Winsock to hook up our provider. |
647 | * It is the only function that [should be/is] exported by the | 647 | * It is the only function that [should be/is] exported by the |
648 | * provider. All other routines are passed as pointers in lpnspRoutines. | 648 | * provider. All other routines are passed as pointers in lpnspRoutines. |
649 | */ | 649 | */ |
650 | int WSPAPI | 650 | int WSPAPI |
651 | NSPStartup (LPGUID lpProviderId, LPNSP_ROUTINE lpnspRoutines) | 651 | NSPStartup (LPGUID lpProviderId, LPNSP_ROUTINE lpnspRoutines) |
652 | { | 652 | { |
653 | if (IsEqualGUID (lpProviderId, &GNUNET_NAMESPACE_PROVIDER_DNS)) | 653 | if (IsEqualGUID (lpProviderId, &GNUNET_NAMESPACE_PROVIDER_DNS)) |
654 | { | 654 | { |
655 | if (!connect_to_dns_resolver ()) | 655 | if (!connect_to_dns_resolver ()) |
656 | { | 656 | { |
657 | return SOCKET_ERROR; | 657 | return SOCKET_ERROR; |
658 | } | 658 | } |
659 | /* This assumes that NSP_ROUTINE struct doesn't have a NSPIoctl member. | 659 | /* This assumes that NSP_ROUTINE struct doesn't have a NSPIoctl member. |
660 | * If it does, you need to use FIELD_OFFSET() macro to get offset of NSPIoctl | 660 | * If it does, you need to use FIELD_OFFSET() macro to get offset of NSPIoctl |
661 | * and use that offset as cbSize. | 661 | * and use that offset as cbSize. |
662 | */ | 662 | */ |
663 | lpnspRoutines->cbSize = sizeof(NSP_ROUTINE_XP); | 663 | lpnspRoutines->cbSize = sizeof(NSP_ROUTINE_XP); |
664 | 664 | ||
665 | lpnspRoutines->dwMajorVersion = NSPAPI_VERSION_MAJOR; | 665 | lpnspRoutines->dwMajorVersion = NSPAPI_VERSION_MAJOR; |
666 | lpnspRoutines->dwMinorVersion = NSPAPI_VERSION_MINOR; | 666 | lpnspRoutines->dwMinorVersion = NSPAPI_VERSION_MINOR; |
667 | lpnspRoutines->NSPCleanup = NSPCleanup; | 667 | lpnspRoutines->NSPCleanup = NSPCleanup; |
668 | lpnspRoutines->NSPLookupServiceBegin = GNUNET_W32NSP_LookupServiceBegin; | 668 | lpnspRoutines->NSPLookupServiceBegin = GNUNET_W32NSP_LookupServiceBegin; |
669 | lpnspRoutines->NSPLookupServiceNext = GNUNET_W32NSP_LookupServiceNext; | 669 | lpnspRoutines->NSPLookupServiceNext = GNUNET_W32NSP_LookupServiceNext; |
670 | lpnspRoutines->NSPLookupServiceEnd = GNUNET_W32NSP_LookupServiceEnd; | 670 | lpnspRoutines->NSPLookupServiceEnd = GNUNET_W32NSP_LookupServiceEnd; |
671 | lpnspRoutines->NSPSetService = GNUNET_W32NSP_SetService; | 671 | lpnspRoutines->NSPSetService = GNUNET_W32NSP_SetService; |
672 | lpnspRoutines->NSPInstallServiceClass = GNUNET_W32NSP_InstallServiceClass; | 672 | lpnspRoutines->NSPInstallServiceClass = GNUNET_W32NSP_InstallServiceClass; |
673 | lpnspRoutines->NSPRemoveServiceClass = GNUNET_W32NSP_RemoveServiceClass; | 673 | lpnspRoutines->NSPRemoveServiceClass = GNUNET_W32NSP_RemoveServiceClass; |
674 | lpnspRoutines->NSPGetServiceClassInfo = GNUNET_W32NSP_GetServiceClassInfo; | 674 | lpnspRoutines->NSPGetServiceClassInfo = GNUNET_W32NSP_GetServiceClassInfo; |
675 | ((NSP_ROUTINE_XP *) lpnspRoutines)->NSPIoctl = GNUNET_W32NSP_Ioctl; | 675 | ((NSP_ROUTINE_XP *) lpnspRoutines)->NSPIoctl = GNUNET_W32NSP_Ioctl; |
676 | return NO_ERROR; | 676 | return NO_ERROR; |
677 | } | 677 | } |
678 | SetLastError (WSAEINVALIDPROVIDER); | 678 | SetLastError (WSAEINVALIDPROVIDER); |
679 | return SOCKET_ERROR; | 679 | return SOCKET_ERROR; |
680 | } | 680 | } |
681 | 681 | ||