Merge branch 'vendor/WPA_SUPPLICANT'
[dragonfly.git] / contrib / wpa_supplicant / src / wps / wps_upnp.c
1 /*
2  * UPnP WPS Device
3  * Copyright (c) 2000-2003 Intel Corporation
4  * Copyright (c) 2006-2007 Sony Corporation
5  * Copyright (c) 2008-2009 Atheros Communications
6  * Copyright (c) 2009-2010, Jouni Malinen <j@w1.fi>
7  *
8  * See below for more details on licensing and code history.
9  */
10
11 /*
12  * This has been greatly stripped down from the original file
13  * (upnp_wps_device.c) by Ted Merrill, Atheros Communications
14  * in order to eliminate use of the bulky libupnp library etc.
15  *
16  * History:
17  * upnp_wps_device.c is/was a shim layer between wps_opt_upnp.c and
18  * the libupnp library.
19  * The layering (by Sony) was well done; only a very minor modification
20  * to API of upnp_wps_device.c was required.
21  * libupnp was found to be undesirable because:
22  * -- It consumed too much code and data space
23  * -- It uses multiple threads, making debugging more difficult
24  *      and possibly reducing reliability.
25  * -- It uses static variables and only supports one instance.
26  * The shim and libupnp are here replaced by special code written
27  * specifically for the needs of hostapd.
28  * Various shortcuts can and are taken to keep the code size small.
29  * Generally, execution time is not as crucial.
30  *
31  * BUGS:
32  * -- UPnP requires that we be able to resolve domain names.
33  * While uncommon, if we have to do it then it will stall the entire
34  * hostapd program, which is bad.
35  * This is because we use the standard linux getaddrinfo() function
36  * which is syncronous.
37  * An asyncronous solution would be to use the free "ares" library.
38  * -- Does not have a robust output buffering scheme.  Uses a single
39  * fixed size output buffer per TCP/HTTP connection, with possible (although
40  * unlikely) possibility of overflow and likely excessive use of RAM.
41  * A better solution would be to write the HTTP output as a buffered stream,
42  * using chunking: (handle header specially, then) generate data with
43  * a printf-like function into a buffer, catching buffer full condition,
44  * then send it out surrounded by http chunking.
45  * -- There is some code that could be separated out into the common
46  * library to be shared with wpa_supplicant.
47  * -- Needs renaming with module prefix to avoid polluting the debugger
48  * namespace and causing possible collisions with other static fncs
49  * and structure declarations when using the debugger.
50  * -- The http error code generation is pretty bogus, hopefully no one cares.
51  *
52  * Author: Ted Merrill, Atheros Communications, based upon earlier work
53  * as explained above and below.
54  *
55  * Copyright:
56  * Copyright 2008 Atheros Communications.
57  *
58  * The original header (of upnp_wps_device.c) reads:
59  *
60  *  Copyright (c) 2006-2007 Sony Corporation. All Rights Reserved.
61  *
62  *  File Name: upnp_wps_device.c
63  *  Description: EAP-WPS UPnP device source
64  *
65  *   Redistribution and use in source and binary forms, with or without
66  *   modification, are permitted provided that the following conditions
67  *   are met:
68  *
69  *     * Redistributions of source code must retain the above copyright
70  *       notice, this list of conditions and the following disclaimer.
71  *     * Redistributions in binary form must reproduce the above copyright
72  *       notice, this list of conditions and the following disclaimer in
73  *       the documentation and/or other materials provided with the
74  *       distribution.
75  *     * Neither the name of Sony Corporation nor the names of its
76  *       contributors may be used to endorse or promote products derived
77  *       from this software without specific prior written permission.
78  *
79  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
80  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
81  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
82  *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
83  *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
84  *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
85  *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
86  *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
87  *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
88  *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
89  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
90  *
91  * Portions from Intel libupnp files, e.g. genlib/net/http/httpreadwrite.c
92  * typical header:
93  *
94  * Copyright (c) 2000-2003 Intel Corporation
95  * All rights reserved.
96  *
97  * Redistribution and use in source and binary forms, with or without
98  * modification, are permitted provided that the following conditions are met:
99  *
100  * * Redistributions of source code must retain the above copyright notice,
101  * this list of conditions and the following disclaimer.
102  * * Redistributions in binary form must reproduce the above copyright notice,
103  * this list of conditions and the following disclaimer in the documentation
104  * and/or other materials provided with the distribution.
105  * * Neither name of Intel Corporation nor the names of its contributors
106  * may be used to endorse or promote products derived from this software
107  * without specific prior written permission.
108  *
109  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
110  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
111  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
112  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL INTEL OR
113  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
114  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
115  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
116  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
117  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
118  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
119  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
120 */
121
122 /*
123  * Overview of WPS over UPnP:
124  *
125  * UPnP is a protocol that allows devices to discover each other and control
126  * each other. In UPnP terminology, a device is either a "device" (a server
127  * that provides information about itself and allows itself to be controlled)
128  * or a "control point" (a client that controls "devices") or possibly both.
129  * This file implements a UPnP "device".
130  *
131  * For us, we use mostly basic UPnP discovery, but the control part of interest
132  * is WPS carried via UPnP messages. There is quite a bit of basic UPnP
133  * discovery to do before we can get to WPS, however.
134  *
135  * UPnP discovery begins with "devices" send out multicast UDP packets to a
136  * certain fixed multicast IP address and port, and "control points" sending
137  * out other such UDP packets.
138  *
139  * The packets sent by devices are NOTIFY packets (not to be confused with TCP
140  * NOTIFY packets that are used later) and those sent by control points are
141  * M-SEARCH packets. These packets contain a simple HTTP style header. The
142  * packets are sent redundantly to get around packet loss. Devices respond to
143  * M-SEARCH packets with HTTP-like UDP packets containing HTTP/1.1 200 OK
144  * messages, which give similar information as the UDP NOTIFY packets.
145  *
146  * The above UDP packets advertise the (arbitrary) TCP ports that the
147  * respective parties will listen to. The control point can then do a HTTP
148  * SUBSCRIBE (something like an HTTP PUT) after which the device can do a
149  * separate HTTP NOTIFY (also like an HTTP PUT) to do event messaging.
150  *
151  * The control point will also do HTTP GET of the "device file" listed in the
152  * original UDP information from the device (see UPNP_WPS_DEVICE_XML_FILE
153  * data), and based on this will do additional GETs... HTTP POSTs are done to
154  * cause an action.
155  *
156  * Beyond some basic information in HTTP headers, additional information is in
157  * the HTTP bodies, in a format set by the SOAP and XML standards, a markup
158  * language related to HTML used for web pages. This language is intended to
159  * provide the ultimate in self-documentation by providing a universal
160  * namespace based on pseudo-URLs called URIs. Note that although a URI looks
161  * like a URL (a web address), they are never accessed as such but are used
162  * only as identifiers.
163  *
164  * The POST of a GetDeviceInfo gets information similar to what might be
165  * obtained from a probe request or response on Wi-Fi. WPS messages M1-M8
166  * are passed via a POST of a PutMessage; the M1-M8 WPS messages are converted
167  * to a bin64 ascii representation for encapsulation. When proxying messages,
168  * WLANEvent and PutWLANResponse are used.
169  *
170  * This of course glosses over a lot of details.
171  */
172
173 #include "includes.h"
174
175 #include <time.h>
176 #include <net/if.h>
177 #include <netdb.h>
178 #include <sys/ioctl.h>
179
180 #include "common.h"
181 #include "uuid.h"
182 #include "base64.h"
183 #include "wps.h"
184 #include "wps_i.h"
185 #include "wps_upnp.h"
186 #include "wps_upnp_i.h"
187
188
189 /*
190  * UPnP allows a client ("control point") to send a server like us ("device")
191  * a domain name for registration, and we are supposed to resolve it. This is
192  * bad because, using the standard Linux library, we will stall the entire
193  * hostapd waiting for resolution.
194  *
195  * The "correct" solution would be to use an event driven library for domain
196  * name resolution such as "ares". However, this would increase code size
197  * further. Since it is unlikely that we'll actually see such domain names, we
198  * can just refuse to accept them.
199  */
200 #define NO_DOMAIN_NAME_RESOLUTION 1  /* 1 to allow only dotted ip addresses */
201
202
203 /*
204  * UPnP does not scale well. If we were in a room with thousands of control
205  * points then potentially we could be expected to handle subscriptions for
206  * each of them, which would exhaust our memory. So we must set a limit. In
207  * practice we are unlikely to see more than one or two.
208  */
209 #define MAX_SUBSCRIPTIONS 4    /* how many subscribing clients we handle */
210 #define MAX_ADDR_PER_SUBSCRIPTION 8
211
212 /* Maximum number of Probe Request events per second */
213 #define MAX_EVENTS_PER_SEC 5
214
215
216 static struct upnp_wps_device_sm *shared_upnp_device = NULL;
217
218
219 /* Write the current date/time per RFC */
220 void format_date(struct wpabuf *buf)
221 {
222         const char *weekday_str = "Sun\0Mon\0Tue\0Wed\0Thu\0Fri\0Sat";
223         const char *month_str = "Jan\0Feb\0Mar\0Apr\0May\0Jun\0"
224                 "Jul\0Aug\0Sep\0Oct\0Nov\0Dec";
225         struct tm *date;
226         time_t t;
227
228         t = time(NULL);
229         date = gmtime(&t);
230         if (date == NULL)
231                 return;
232         wpabuf_printf(buf, "%s, %02d %s %d %02d:%02d:%02d GMT",
233                       &weekday_str[date->tm_wday * 4], date->tm_mday,
234                       &month_str[date->tm_mon * 4], date->tm_year + 1900,
235                       date->tm_hour, date->tm_min, date->tm_sec);
236 }
237
238
239 /***************************************************************************
240  * UUIDs (unique identifiers)
241  *
242  * These are supposed to be unique in all the world.
243  * Sometimes permanent ones are used, sometimes temporary ones
244  * based on random numbers... there are different rules for valid content
245  * of different types.
246  * Each uuid is 16 bytes long.
247  **************************************************************************/
248
249 /* uuid_make -- construct a random UUID
250  * The UPnP documents don't seem to offer any guidelines as to which method to
251  * use for constructing UUIDs for subscriptions. Presumably any method from
252  * rfc4122 is good enough; I've chosen random number method.
253  */
254 static int uuid_make(u8 uuid[UUID_LEN])
255 {
256         if (os_get_random(uuid, UUID_LEN) < 0)
257                 return -1;
258
259         /* Replace certain bits as specified in rfc4122 or X.667 */
260         uuid[6] &= 0x0f; uuid[6] |= (4 << 4);   /* version 4 == random gen */
261         uuid[8] &= 0x3f; uuid[8] |= 0x80;
262
263         return 0;
264 }
265
266
267 /*
268  * Subscriber address handling.
269  * Since a subscriber may have an arbitrary number of addresses, we have to
270  * add a bunch of code to handle them.
271  *
272  * Addresses are passed in text, and MAY be domain names instead of the (usual
273  * and expected) dotted IP addresses. Resolving domain names consumes a lot of
274  * resources. Worse, we are currently using the standard Linux getaddrinfo()
275  * which will block the entire program until complete or timeout! The proper
276  * solution would be to use the "ares" library or similar with more state
277  * machine steps etc. or just disable domain name resolution by setting
278  * NO_DOMAIN_NAME_RESOLUTION to 1 at top of this file.
279  */
280
281 /* subscr_addr_delete -- delete single unlinked subscriber address
282  * (be sure to unlink first if need be)
283  */
284 void subscr_addr_delete(struct subscr_addr *a)
285 {
286         /*
287          * Note: do NOT free domain_and_port or path because they point to
288          * memory within the allocation of "a".
289          */
290         os_free(a);
291 }
292
293
294 /* subscr_addr_free_all -- unlink and delete list of subscriber addresses. */
295 static void subscr_addr_free_all(struct subscription *s)
296 {
297         struct subscr_addr *a, *tmp;
298         dl_list_for_each_safe(a, tmp, &s->addr_list, struct subscr_addr, list)
299         {
300                 dl_list_del(&a->list);
301                 subscr_addr_delete(a);
302         }
303 }
304
305
306 /* subscr_addr_add_url -- add address(es) for one url to subscription */
307 static void subscr_addr_add_url(struct subscription *s, const char *url,
308                                 size_t url_len)
309 {
310         int alloc_len;
311         char *scratch_mem = NULL;
312         char *mem;
313         char *host;
314         char *delim;
315         char *path;
316         int port = 80;  /* port to send to (default is port 80) */
317         struct addrinfo hints;
318         struct addrinfo *result = NULL;
319         struct addrinfo *rp;
320         int rerr;
321         size_t host_len, path_len;
322
323         /* url MUST begin with http: */
324         if (url_len < 7 || os_strncasecmp(url, "http://", 7))
325                 goto fail;
326         url += 7;
327         url_len -= 7;
328
329         /* Make a copy of the string to allow modification during parsing */
330         scratch_mem = dup_binstr(url, url_len);
331         if (scratch_mem == NULL)
332                 goto fail;
333         wpa_printf(MSG_DEBUG, "WPS UPnP: Adding URL '%s'", scratch_mem);
334         host = scratch_mem;
335         path = os_strchr(host, '/');
336         if (path)
337                 *path++ = '\0'; /* null terminate host */
338
339         /* Process and remove optional port component */
340         delim = os_strchr(host, ':');
341         if (delim) {
342                 *delim = '\0'; /* null terminate host name for now */
343                 if (isdigit(delim[1]))
344                         port = atol(delim + 1);
345         }
346
347         /*
348          * getaddrinfo does the right thing with dotted decimal notations, or
349          * will resolve domain names. Resolving domain names will unfortunately
350          * hang the entire program until it is resolved or it times out
351          * internal to getaddrinfo; fortunately we think that the use of actual
352          * domain names (vs. dotted decimal notations) should be uncommon.
353          */
354         os_memset(&hints, 0, sizeof(struct addrinfo));
355         hints.ai_family = AF_INET;      /* IPv4 */
356         hints.ai_socktype = SOCK_STREAM;
357 #if NO_DOMAIN_NAME_RESOLUTION
358         /* Suppress domain name resolutions that would halt
359          * the program for periods of time
360          */
361         hints.ai_flags = AI_NUMERICHOST;
362 #else
363         /* Allow domain name resolution. */
364         hints.ai_flags = 0;
365 #endif
366         hints.ai_protocol = 0;          /* Any protocol? */
367         rerr = getaddrinfo(host, NULL /* fill in port ourselves */,
368                            &hints, &result);
369         if (rerr) {
370                 wpa_printf(MSG_INFO, "WPS UPnP: Resolve error %d (%s) on: %s",
371                            rerr, gai_strerror(rerr), host);
372                 goto fail;
373         }
374
375         if (delim)
376                 *delim = ':'; /* Restore port */
377
378         host_len = os_strlen(host);
379         path_len = path ? os_strlen(path) : 0;
380         alloc_len = host_len + 1 + 1 + path_len + 1;
381
382         for (rp = result; rp; rp = rp->ai_next) {
383                 struct subscr_addr *a;
384
385                 /* Limit no. of address to avoid denial of service attack */
386                 if (dl_list_len(&s->addr_list) >= MAX_ADDR_PER_SUBSCRIPTION) {
387                         wpa_printf(MSG_INFO, "WPS UPnP: subscr_addr_add_url: "
388                                    "Ignoring excessive addresses");
389                         break;
390                 }
391
392                 a = os_zalloc(sizeof(*a) + alloc_len);
393                 if (a == NULL)
394                         break;
395                 mem = (char *) (a + 1);
396                 a->domain_and_port = mem;
397                 os_memcpy(mem, host, host_len);
398                 mem += host_len + 1;
399                 a->path = mem;
400                 if (path == NULL || path[0] != '/')
401                         *mem++ = '/';
402                 if (path)
403                         os_memcpy(mem, path, path_len);
404                 os_memcpy(&a->saddr, rp->ai_addr, sizeof(a->saddr));
405                 a->saddr.sin_port = htons(port);
406
407                 dl_list_add(&s->addr_list, &a->list);
408         }
409
410 fail:
411         if (result)
412                 freeaddrinfo(result);
413         os_free(scratch_mem);
414 }
415
416
417 /* subscr_addr_list_create -- create list from urls in string.
418  *      Each url is enclosed by angle brackets.
419  */
420 static void subscr_addr_list_create(struct subscription *s,
421                                     const char *url_list)
422 {
423         const char *end;
424         wpa_printf(MSG_DEBUG, "WPS UPnP: Parsing URL list '%s'", url_list);
425         for (;;) {
426                 while (*url_list == ' ' || *url_list == '\t')
427                         url_list++;
428                 if (*url_list != '<')
429                         break;
430                 url_list++;
431                 end = os_strchr(url_list, '>');
432                 if (end == NULL)
433                         break;
434                 subscr_addr_add_url(s, url_list, end - url_list);
435                 url_list = end + 1;
436         }
437 }
438
439
440 static void wpabuf_put_property(struct wpabuf *buf, const char *name,
441                                 const char *value)
442 {
443         wpabuf_put_str(buf, "<e:property>");
444         wpabuf_printf(buf, "<%s>", name);
445         if (value)
446                 wpabuf_put_str(buf, value);
447         wpabuf_printf(buf, "</%s>", name);
448         wpabuf_put_str(buf, "</e:property>\n");
449 }
450
451
452 /**
453  * upnp_wps_device_send_event - Queue event messages for subscribers
454  * @sm: WPS UPnP state machine from upnp_wps_device_init()
455  *
456  * This function queues the last WLANEvent to be sent for all currently
457  * subscribed UPnP control points. sm->wlanevent must have been set with the
458  * encoded data before calling this function.
459  */
460 static void upnp_wps_device_send_event(struct upnp_wps_device_sm *sm)
461 {
462         /* Enqueue event message for all subscribers */
463         struct wpabuf *buf; /* holds event message */
464         int buf_size = 0;
465         struct subscription *s, *tmp;
466         /* Actually, utf-8 is the default, but it doesn't hurt to specify it */
467         const char *format_head =
468                 "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"
469                 "<e:propertyset xmlns:e=\"urn:schemas-upnp-org:event-1-0\">\n";
470         const char *format_tail = "</e:propertyset>\n";
471         struct os_reltime now;
472
473         if (dl_list_empty(&sm->subscriptions)) {
474                 /* optimize */
475                 return;
476         }
477
478         if (os_get_reltime(&now) == 0) {
479                 if (now.sec != sm->last_event_sec) {
480                         sm->last_event_sec = now.sec;
481                         sm->num_events_in_sec = 1;
482                 } else {
483                         sm->num_events_in_sec++;
484                         /*
485                          * In theory, this should apply to all WLANEvent
486                          * notifications, but EAP messages are of much higher
487                          * priority and Probe Request notifications should not
488                          * be allowed to drop EAP messages, so only throttle
489                          * Probe Request notifications.
490                          */
491                         if (sm->num_events_in_sec > MAX_EVENTS_PER_SEC &&
492                             sm->wlanevent_type ==
493                             UPNP_WPS_WLANEVENT_TYPE_PROBE) {
494                                 wpa_printf(MSG_DEBUG, "WPS UPnP: Throttle "
495                                            "event notifications (%u seen "
496                                            "during one second)",
497                                            sm->num_events_in_sec);
498                                 return;
499                         }
500                 }
501         }
502
503         /* Determine buffer size needed first */
504         buf_size += os_strlen(format_head);
505         buf_size += 50 + 2 * os_strlen("WLANEvent");
506         if (sm->wlanevent)
507                 buf_size += os_strlen(sm->wlanevent);
508         buf_size += os_strlen(format_tail);
509
510         buf = wpabuf_alloc(buf_size);
511         if (buf == NULL)
512                 return;
513         wpabuf_put_str(buf, format_head);
514         wpabuf_put_property(buf, "WLANEvent", sm->wlanevent);
515         wpabuf_put_str(buf, format_tail);
516
517         wpa_printf(MSG_MSGDUMP, "WPS UPnP: WLANEvent message:\n%s",
518                    (char *) wpabuf_head(buf));
519
520         dl_list_for_each_safe(s, tmp, &sm->subscriptions, struct subscription,
521                               list) {
522                 event_add(s, buf,
523                           sm->wlanevent_type == UPNP_WPS_WLANEVENT_TYPE_PROBE);
524         }
525
526         wpabuf_free(buf);
527 }
528
529
530 /*
531  * Event subscription (subscriber machines register with us to receive event
532  * messages).
533  * This is the result of an incoming HTTP over TCP SUBSCRIBE request.
534  */
535
536 /* subscription_destroy -- destroy an unlinked subscription
537  * Be sure to unlink first if necessary.
538  */
539 void subscription_destroy(struct subscription *s)
540 {
541         struct upnp_wps_device_interface *iface;
542         wpa_printf(MSG_DEBUG, "WPS UPnP: Destroy subscription %p", s);
543         subscr_addr_free_all(s);
544         event_delete_all(s);
545         dl_list_for_each(iface, &s->sm->interfaces,
546                          struct upnp_wps_device_interface, list)
547                 upnp_er_remove_notification(iface->wps->registrar, s);
548         os_free(s);
549 }
550
551
552 /* subscription_list_age -- remove expired subscriptions */
553 static void subscription_list_age(struct upnp_wps_device_sm *sm, time_t now)
554 {
555         struct subscription *s, *tmp;
556         dl_list_for_each_safe(s, tmp, &sm->subscriptions,
557                               struct subscription, list) {
558                 if (s->timeout_time > now)
559                         break;
560                 wpa_printf(MSG_DEBUG, "WPS UPnP: Removing aged subscription");
561                 dl_list_del(&s->list);
562                 subscription_destroy(s);
563         }
564 }
565
566
567 /* subscription_find -- return existing subscription matching uuid, if any
568  * returns NULL if not found
569  */
570 struct subscription * subscription_find(struct upnp_wps_device_sm *sm,
571                                         const u8 uuid[UUID_LEN])
572 {
573         struct subscription *s;
574         dl_list_for_each(s, &sm->subscriptions, struct subscription, list) {
575                 if (os_memcmp(s->uuid, uuid, UUID_LEN) == 0)
576                         return s; /* Found match */
577         }
578         return NULL;
579 }
580
581
582 static struct wpabuf * build_fake_wsc_ack(void)
583 {
584         struct wpabuf *msg = wpabuf_alloc(100);
585         if (msg == NULL)
586                 return NULL;
587         wpabuf_put_u8(msg, UPNP_WPS_WLANEVENT_TYPE_EAP);
588         wpabuf_put_str(msg, "00:00:00:00:00:00");
589         if (wps_build_version(msg) ||
590             wps_build_msg_type(msg, WPS_WSC_ACK)) {
591                 wpabuf_free(msg);
592                 return NULL;
593         }
594         /* Enrollee Nonce */
595         wpabuf_put_be16(msg, ATTR_ENROLLEE_NONCE);
596         wpabuf_put_be16(msg, WPS_NONCE_LEN);
597         wpabuf_put(msg, WPS_NONCE_LEN);
598         /* Registrar Nonce */
599         wpabuf_put_be16(msg, ATTR_REGISTRAR_NONCE);
600         wpabuf_put_be16(msg, WPS_NONCE_LEN);
601         wpabuf_put(msg, WPS_NONCE_LEN);
602         if (wps_build_wfa_ext(msg, 0, NULL, 0, 0)) {
603                 wpabuf_free(msg);
604                 return NULL;
605         }
606         return msg;
607 }
608
609
610 /* subscription_first_event -- send format/queue event that is automatically
611  * sent on a new subscription.
612  */
613 static int subscription_first_event(struct subscription *s)
614 {
615         /*
616          * Actually, utf-8 is the default, but it doesn't hurt to specify it.
617          *
618          * APStatus is apparently a bit set,
619          * 0x1 = configuration change (but is always set?)
620          * 0x10 = ap is locked
621          *
622          * Per UPnP spec, we send out the last value of each variable, even
623          * for WLANEvent, whatever it was.
624          */
625         char *wlan_event;
626         struct wpabuf *buf;
627         int ap_status = 1;      /* TODO: add 0x10 if access point is locked */
628         const char *head =
629                 "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"
630                 "<e:propertyset xmlns:e=\"urn:schemas-upnp-org:event-1-0\">\n";
631         const char *tail = "</e:propertyset>\n";
632         char txt[10];
633         int ret;
634
635         if (s->sm->wlanevent == NULL) {
636                 /*
637                  * There has been no events before the subscription. However,
638                  * UPnP device architecture specification requires all the
639                  * evented variables to be included, so generate a dummy event
640                  * for this particular case using a WSC_ACK and all-zeros
641                  * nonces. The ER (UPnP control point) will ignore this, but at
642                  * least it will learn that WLANEvent variable will be used in
643                  * event notifications in the future.
644                  */
645                 struct wpabuf *msg;
646                 wpa_printf(MSG_DEBUG, "WPS UPnP: Use a fake WSC_ACK as the "
647                            "initial WLANEvent");
648                 msg = build_fake_wsc_ack();
649                 if (msg) {
650                         s->sm->wlanevent = (char *)
651                                 base64_encode(wpabuf_head(msg),
652                                               wpabuf_len(msg), NULL);
653                         wpabuf_free(msg);
654                 }
655         }
656
657         wlan_event = s->sm->wlanevent;
658         if (wlan_event == NULL || *wlan_event == '\0') {
659                 wpa_printf(MSG_DEBUG, "WPS UPnP: WLANEvent not known for "
660                            "initial event message");
661                 wlan_event = "";
662         }
663         buf = wpabuf_alloc(500 + os_strlen(wlan_event));
664         if (buf == NULL)
665                 return -1;
666
667         wpabuf_put_str(buf, head);
668         wpabuf_put_property(buf, "STAStatus", "1");
669         os_snprintf(txt, sizeof(txt), "%d", ap_status);
670         wpabuf_put_property(buf, "APStatus", txt);
671         if (*wlan_event)
672                 wpabuf_put_property(buf, "WLANEvent", wlan_event);
673         wpabuf_put_str(buf, tail);
674
675         ret = event_add(s, buf, 0);
676         if (ret) {
677                 wpabuf_free(buf);
678                 return ret;
679         }
680         wpabuf_free(buf);
681
682         return 0;
683 }
684
685
686 /**
687  * subscription_start - Remember a UPnP control point to send events to.
688  * @sm: WPS UPnP state machine from upnp_wps_device_init()
689  * @callback_urls: Callback URLs
690  * Returns: %NULL on error, or pointer to new subscription structure.
691  */
692 struct subscription * subscription_start(struct upnp_wps_device_sm *sm,
693                                          const char *callback_urls)
694 {
695         struct subscription *s;
696         time_t now = time(NULL);
697         time_t expire = now + UPNP_SUBSCRIBE_SEC;
698         char str[80];
699
700         /* Get rid of expired subscriptions so we have room */
701         subscription_list_age(sm, now);
702
703         /* If too many subscriptions, remove oldest */
704         if (dl_list_len(&sm->subscriptions) >= MAX_SUBSCRIPTIONS) {
705                 s = dl_list_first(&sm->subscriptions, struct subscription,
706                                   list);
707                 if (s) {
708                         wpa_printf(MSG_INFO,
709                                    "WPS UPnP: Too many subscriptions, trashing oldest");
710                         dl_list_del(&s->list);
711                         subscription_destroy(s);
712                 }
713         }
714
715         s = os_zalloc(sizeof(*s));
716         if (s == NULL)
717                 return NULL;
718         dl_list_init(&s->addr_list);
719         dl_list_init(&s->event_queue);
720
721         s->sm = sm;
722         s->timeout_time = expire;
723         if (uuid_make(s->uuid) < 0) {
724                 subscription_destroy(s);
725                 return NULL;
726         }
727         subscr_addr_list_create(s, callback_urls);
728         if (dl_list_empty(&s->addr_list)) {
729                 wpa_printf(MSG_DEBUG, "WPS UPnP: No valid callback URLs in "
730                            "'%s' - drop subscription", callback_urls);
731                 subscription_destroy(s);
732                 return NULL;
733         }
734
735         /* Add to end of list, since it has the highest expiration time */
736         dl_list_add_tail(&sm->subscriptions, &s->list);
737         /* Queue up immediate event message (our last event)
738          * as required by UPnP spec.
739          */
740         if (subscription_first_event(s)) {
741                 wpa_printf(MSG_INFO, "WPS UPnP: Dropping subscriber due to "
742                            "event backlog");
743                 dl_list_del(&s->list);
744                 subscription_destroy(s);
745                 return NULL;
746         }
747         uuid_bin2str(s->uuid, str, sizeof(str));
748         wpa_printf(MSG_DEBUG,
749                    "WPS UPnP: Subscription %p (SID %s) started with %s",
750                    s, str, callback_urls);
751         /* Schedule sending this */
752         event_send_all_later(sm);
753         return s;
754 }
755
756
757 /* subscription_renew -- find subscription and reset timeout */
758 struct subscription * subscription_renew(struct upnp_wps_device_sm *sm,
759                                          const u8 uuid[UUID_LEN])
760 {
761         time_t now = time(NULL);
762         time_t expire = now + UPNP_SUBSCRIBE_SEC;
763         struct subscription *s = subscription_find(sm, uuid);
764         if (s == NULL)
765                 return NULL;
766         wpa_printf(MSG_DEBUG, "WPS UPnP: Subscription renewed");
767         dl_list_del(&s->list);
768         s->timeout_time = expire;
769         /* add back to end of list, since it now has highest expiry */
770         dl_list_add_tail(&sm->subscriptions, &s->list);
771         return s;
772 }
773
774
775 /**
776  * upnp_wps_device_send_wlan_event - Event notification
777  * @sm: WPS UPnP state machine from upnp_wps_device_init()
778  * @from_mac_addr: Source (Enrollee) MAC address for the event
779  * @ev_type: Event type
780  * @msg: Event data
781  * Returns: 0 on success, -1 on failure
782  *
783  * Tell external Registrars (UPnP control points) that something happened. In
784  * particular, events include WPS messages from clients that are proxied to
785  * external Registrars.
786  */
787 int upnp_wps_device_send_wlan_event(struct upnp_wps_device_sm *sm,
788                                     const u8 from_mac_addr[ETH_ALEN],
789                                     enum upnp_wps_wlanevent_type ev_type,
790                                     const struct wpabuf *msg)
791 {
792         int ret = -1;
793         char type[2];
794         const u8 *mac = from_mac_addr;
795         char mac_text[18];
796         u8 *raw = NULL;
797         size_t raw_len;
798         char *val;
799         size_t val_len;
800         int pos = 0;
801
802         if (!sm)
803                 goto fail;
804
805         os_snprintf(type, sizeof(type), "%1u", ev_type);
806
807         raw_len = 1 + 17 + (msg ? wpabuf_len(msg) : 0);
808         raw = os_zalloc(raw_len);
809         if (!raw)
810                 goto fail;
811
812         *(raw + pos) = (u8) ev_type;
813         pos += 1;
814         os_snprintf(mac_text, sizeof(mac_text), MACSTR, MAC2STR(mac));
815         wpa_printf(MSG_DEBUG, "WPS UPnP: Proxying WLANEvent from %s",
816                    mac_text);
817         os_memcpy(raw + pos, mac_text, 17);
818         pos += 17;
819         if (msg) {
820                 os_memcpy(raw + pos, wpabuf_head(msg), wpabuf_len(msg));
821                 pos += wpabuf_len(msg);
822         }
823         raw_len = pos;
824
825         val = (char *) base64_encode(raw, raw_len, &val_len);
826         if (val == NULL)
827                 goto fail;
828
829         os_free(sm->wlanevent);
830         sm->wlanevent = val;
831         sm->wlanevent_type = ev_type;
832         upnp_wps_device_send_event(sm);
833
834         ret = 0;
835
836 fail:
837         os_free(raw);
838
839         return ret;
840 }
841
842
843 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)
844 #include <sys/sysctl.h>
845 #include <net/route.h>
846 #include <net/if_dl.h>
847
848 static int eth_get(const char *device, u8 ea[ETH_ALEN])
849 {
850         struct if_msghdr *ifm;
851         struct sockaddr_dl *sdl;
852         u_char *p, *buf;
853         size_t len;
854         int mib[] = { CTL_NET, AF_ROUTE, 0, AF_LINK, NET_RT_IFLIST, 0 };
855
856         if (sysctl(mib, 6, NULL, &len, NULL, 0) < 0)
857                 return -1;
858         if ((buf = os_malloc(len)) == NULL)
859                 return -1;
860         if (sysctl(mib, 6, buf, &len, NULL, 0) < 0) {
861                 os_free(buf);
862                 return -1;
863         }
864         for (p = buf; p < buf + len; p += ifm->ifm_msglen) {
865                 ifm = (struct if_msghdr *)p;
866                 sdl = (struct sockaddr_dl *)(ifm + 1);
867                 if (ifm->ifm_type != RTM_IFINFO ||
868                     (ifm->ifm_addrs & RTA_IFP) == 0)
869                         continue;
870                 if (sdl->sdl_family != AF_LINK || sdl->sdl_nlen == 0 ||
871                     os_memcmp(sdl->sdl_data, device, sdl->sdl_nlen) != 0)
872                         continue;
873                 os_memcpy(ea, LLADDR(sdl), sdl->sdl_alen);
874                 break;
875         }
876         os_free(buf);
877
878         if (p >= buf + len) {
879                 errno = ESRCH;
880                 return -1;
881         }
882         return 0;
883 }
884 #endif /* __FreeBSD__ || __DragonFly__ */
885
886
887 /**
888  * get_netif_info - Get hw and IP addresses for network device
889  * @net_if: Selected network interface name
890  * @ip_addr: Buffer for returning IP address in network byte order
891  * @ip_addr_text: Buffer for returning a pointer to allocated IP address text
892  * @mac: Buffer for returning MAC address
893  * Returns: 0 on success, -1 on failure
894  */
895 int get_netif_info(const char *net_if, unsigned *ip_addr, char **ip_addr_text,
896                    u8 mac[ETH_ALEN])
897 {
898         struct ifreq req;
899         int sock = -1;
900         struct sockaddr_in *addr;
901         struct in_addr in_addr;
902
903         *ip_addr_text = os_zalloc(16);
904         if (*ip_addr_text == NULL)
905                 goto fail;
906
907         sock = socket(AF_INET, SOCK_DGRAM, 0);
908         if (sock < 0)
909                 goto fail;
910
911         os_strlcpy(req.ifr_name, net_if, sizeof(req.ifr_name));
912         if (ioctl(sock, SIOCGIFADDR, &req) < 0) {
913                 wpa_printf(MSG_ERROR, "WPS UPnP: SIOCGIFADDR failed: %d (%s)",
914                            errno, strerror(errno));
915                 goto fail;
916         }
917         addr = (void *) &req.ifr_addr;
918         *ip_addr = addr->sin_addr.s_addr;
919         in_addr.s_addr = *ip_addr;
920         os_snprintf(*ip_addr_text, 16, "%s", inet_ntoa(in_addr));
921
922 #ifdef __linux__
923         os_strlcpy(req.ifr_name, net_if, sizeof(req.ifr_name));
924         if (ioctl(sock, SIOCGIFHWADDR, &req) < 0) {
925                 wpa_printf(MSG_ERROR, "WPS UPnP: SIOCGIFHWADDR failed: "
926                            "%d (%s)", errno, strerror(errno));
927                 goto fail;
928         }
929         os_memcpy(mac, req.ifr_addr.sa_data, 6);
930 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)
931         if (eth_get(net_if, mac) < 0) {
932                 wpa_printf(MSG_ERROR, "WPS UPnP: Failed to get MAC address");
933                 goto fail;
934         }
935 #else
936 #error MAC address fetch not implemented
937 #endif
938
939         close(sock);
940         return 0;
941
942 fail:
943         if (sock >= 0)
944                 close(sock);
945         os_free(*ip_addr_text);
946         *ip_addr_text = NULL;
947         return -1;
948 }
949
950
951 static void upnp_wps_free_msearchreply(struct dl_list *head)
952 {
953         struct advertisement_state_machine *a, *tmp;
954         dl_list_for_each_safe(a, tmp, head, struct advertisement_state_machine,
955                               list)
956                 msearchreply_state_machine_stop(a);
957 }
958
959
960 static void upnp_wps_free_subscriptions(struct dl_list *head,
961                                         struct wps_registrar *reg)
962 {
963         struct subscription *s, *tmp;
964         dl_list_for_each_safe(s, tmp, head, struct subscription, list) {
965                 if (reg && s->reg != reg)
966                         continue;
967                 dl_list_del(&s->list);
968                 subscription_destroy(s);
969         }
970 }
971
972
973 /**
974  * upnp_wps_device_stop - Stop WPS UPnP operations on an interface
975  * @sm: WPS UPnP state machine from upnp_wps_device_init()
976  */
977 static void upnp_wps_device_stop(struct upnp_wps_device_sm *sm)
978 {
979         if (!sm || !sm->started)
980                 return;
981
982         wpa_printf(MSG_DEBUG, "WPS UPnP: Stop device");
983         web_listener_stop(sm);
984         ssdp_listener_stop(sm);
985         upnp_wps_free_msearchreply(&sm->msearch_replies);
986         upnp_wps_free_subscriptions(&sm->subscriptions, NULL);
987
988         advertisement_state_machine_stop(sm, 1);
989
990         event_send_stop_all(sm);
991         os_free(sm->wlanevent);
992         sm->wlanevent = NULL;
993         os_free(sm->ip_addr_text);
994         sm->ip_addr_text = NULL;
995         if (sm->multicast_sd >= 0)
996                 close(sm->multicast_sd);
997         sm->multicast_sd = -1;
998
999         sm->started = 0;
1000 }
1001
1002
1003 /**
1004  * upnp_wps_device_start - Start WPS UPnP operations on an interface
1005  * @sm: WPS UPnP state machine from upnp_wps_device_init()
1006  * @net_if: Selected network interface name
1007  * Returns: 0 on success, -1 on failure
1008  */
1009 static int upnp_wps_device_start(struct upnp_wps_device_sm *sm, char *net_if)
1010 {
1011         if (!sm || !net_if)
1012                 return -1;
1013
1014         if (sm->started)
1015                 upnp_wps_device_stop(sm);
1016
1017         sm->multicast_sd = -1;
1018         sm->ssdp_sd = -1;
1019         sm->started = 1;
1020         sm->advertise_count = 0;
1021
1022         /* Fix up linux multicast handling */
1023         if (add_ssdp_network(net_if))
1024                 goto fail;
1025
1026         /* Determine which IP and mac address we're using */
1027         if (get_netif_info(net_if, &sm->ip_addr, &sm->ip_addr_text,
1028                            sm->mac_addr)) {
1029                 wpa_printf(MSG_INFO, "WPS UPnP: Could not get IP/MAC address "
1030                            "for %s. Does it have IP address?", net_if);
1031                 goto fail;
1032         }
1033
1034         /* Listen for incoming TCP connections so that others
1035          * can fetch our "xml files" from us.
1036          */
1037         if (web_listener_start(sm))
1038                 goto fail;
1039
1040         /* Set up for receiving discovery (UDP) packets */
1041         if (ssdp_listener_start(sm))
1042                 goto fail;
1043
1044         /* Set up for sending multicast */
1045         if (ssdp_open_multicast(sm) < 0)
1046                 goto fail;
1047
1048         /*
1049          * Broadcast NOTIFY messages to let the world know we exist.
1050          * This is done via a state machine since the messages should not be
1051          * all sent out at once.
1052          */
1053         if (advertisement_state_machine_start(sm))
1054                 goto fail;
1055
1056         return 0;
1057
1058 fail:
1059         upnp_wps_device_stop(sm);
1060         return -1;
1061 }
1062
1063
1064 static struct upnp_wps_device_interface *
1065 upnp_wps_get_iface(struct upnp_wps_device_sm *sm, void *priv)
1066 {
1067         struct upnp_wps_device_interface *iface;
1068         dl_list_for_each(iface, &sm->interfaces,
1069                          struct upnp_wps_device_interface, list) {
1070                 if (iface->priv == priv)
1071                         return iface;
1072         }
1073         return NULL;
1074 }
1075
1076
1077 /**
1078  * upnp_wps_device_deinit - Deinitialize WPS UPnP
1079  * @sm: WPS UPnP state machine from upnp_wps_device_init()
1080  * @priv: External context data that was used in upnp_wps_device_init() call
1081  */
1082 void upnp_wps_device_deinit(struct upnp_wps_device_sm *sm, void *priv)
1083 {
1084         struct upnp_wps_device_interface *iface;
1085         struct upnp_wps_peer *peer;
1086
1087         if (!sm)
1088                 return;
1089
1090         iface = upnp_wps_get_iface(sm, priv);
1091         if (iface == NULL) {
1092                 wpa_printf(MSG_ERROR, "WPS UPnP: Could not find the interface "
1093                            "instance to deinit");
1094                 return;
1095         }
1096         wpa_printf(MSG_DEBUG, "WPS UPnP: Deinit interface instance %p", iface);
1097         if (dl_list_len(&sm->interfaces) == 1) {
1098                 wpa_printf(MSG_DEBUG, "WPS UPnP: Deinitializing last instance "
1099                            "- free global device instance");
1100                 upnp_wps_device_stop(sm);
1101         } else
1102                 upnp_wps_free_subscriptions(&sm->subscriptions,
1103                                             iface->wps->registrar);
1104         dl_list_del(&iface->list);
1105
1106         while ((peer = dl_list_first(&iface->peers, struct upnp_wps_peer,
1107                                      list))) {
1108                 if (peer->wps)
1109                         wps_deinit(peer->wps);
1110                 dl_list_del(&peer->list);
1111                 os_free(peer);
1112         }
1113         os_free(iface->ctx->ap_pin);
1114         os_free(iface->ctx);
1115         os_free(iface);
1116
1117         if (dl_list_empty(&sm->interfaces)) {
1118                 os_free(sm->root_dir);
1119                 os_free(sm->desc_url);
1120                 os_free(sm);
1121                 shared_upnp_device = NULL;
1122         }
1123 }
1124
1125
1126 /**
1127  * upnp_wps_device_init - Initialize WPS UPnP
1128  * @ctx: callback table; we must eventually free it
1129  * @wps: Pointer to longterm WPS context
1130  * @priv: External context data that will be used in callbacks
1131  * @net_if: Selected network interface name
1132  * Returns: WPS UPnP state or %NULL on failure
1133  */
1134 struct upnp_wps_device_sm *
1135 upnp_wps_device_init(struct upnp_wps_device_ctx *ctx, struct wps_context *wps,
1136                      void *priv, char *net_if)
1137 {
1138         struct upnp_wps_device_sm *sm;
1139         struct upnp_wps_device_interface *iface;
1140         int start = 0;
1141
1142         iface = os_zalloc(sizeof(*iface));
1143         if (iface == NULL) {
1144                 os_free(ctx->ap_pin);
1145                 os_free(ctx);
1146                 return NULL;
1147         }
1148         wpa_printf(MSG_DEBUG, "WPS UPnP: Init interface instance %p", iface);
1149
1150         dl_list_init(&iface->peers);
1151         iface->ctx = ctx;
1152         iface->wps = wps;
1153         iface->priv = priv;
1154
1155         if (shared_upnp_device) {
1156                 wpa_printf(MSG_DEBUG, "WPS UPnP: Share existing device "
1157                            "context");
1158                 sm = shared_upnp_device;
1159         } else {
1160                 wpa_printf(MSG_DEBUG, "WPS UPnP: Initialize device context");
1161                 sm = os_zalloc(sizeof(*sm));
1162                 if (!sm) {
1163                         wpa_printf(MSG_ERROR, "WPS UPnP: upnp_wps_device_init "
1164                                    "failed");
1165                         os_free(iface);
1166                         os_free(ctx->ap_pin);
1167                         os_free(ctx);
1168                         return NULL;
1169                 }
1170                 shared_upnp_device = sm;
1171
1172                 dl_list_init(&sm->msearch_replies);
1173                 dl_list_init(&sm->subscriptions);
1174                 dl_list_init(&sm->interfaces);
1175                 start = 1;
1176         }
1177
1178         dl_list_add(&sm->interfaces, &iface->list);
1179
1180         if (start && upnp_wps_device_start(sm, net_if)) {
1181                 upnp_wps_device_deinit(sm, priv);
1182                 return NULL;
1183         }
1184
1185
1186         return sm;
1187 }
1188
1189
1190 /**
1191  * upnp_wps_subscribers - Check whether there are any event subscribers
1192  * @sm: WPS UPnP state machine from upnp_wps_device_init()
1193  * Returns: 0 if no subscribers, 1 if subscribers
1194  */
1195 int upnp_wps_subscribers(struct upnp_wps_device_sm *sm)
1196 {
1197         return !dl_list_empty(&sm->subscriptions);
1198 }
1199
1200
1201 int upnp_wps_set_ap_pin(struct upnp_wps_device_sm *sm, const char *ap_pin)
1202 {
1203         struct upnp_wps_device_interface *iface;
1204         if (sm == NULL)
1205                 return 0;
1206
1207         dl_list_for_each(iface, &sm->interfaces,
1208                          struct upnp_wps_device_interface, list) {
1209                 os_free(iface->ctx->ap_pin);
1210                 if (ap_pin) {
1211                         iface->ctx->ap_pin = os_strdup(ap_pin);
1212                         if (iface->ctx->ap_pin == NULL)
1213                                 return -1;
1214                 } else
1215                         iface->ctx->ap_pin = NULL;
1216         }
1217
1218         return 0;
1219 }