1 /* 2 * UPnP WPS Device - Event processing 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, Jouni Malinen <j@w1.fi> 7 * 8 * See wps_upnp.c for more details on licensing and code history. 9 */ 10 11 #include "includes.h" 12 #include <assert.h> 13 #include <fcntl.h> 14 15 #include "common.h" 16 #include "eloop.h" 17 #include "uuid.h" 18 #include "httpread.h" 19 #include "wps_defs.h" 20 #include "wps_upnp.h" 21 #include "wps_upnp_i.h" 22 23 /* 24 * Event message generation (to subscribers) 25 * 26 * We make a separate copy for each message for each subscriber. This memory 27 * wasted could be limited (adding code complexity) by sharing copies, keeping 28 * a usage count and freeing when zero. 29 * 30 * Sending a message requires using a HTTP over TCP NOTIFY 31 * (like a PUT) which requires a number of states.. 32 */ 33 34 #define MAX_EVENTS_QUEUED 20 /* How far behind queued events */ 35 #define EVENT_TIMEOUT_SEC 30 /* Drop sending event after timeout */ 36 37 /* How long to wait before sending event */ 38 #define EVENT_DELAY_SECONDS 0 39 #define EVENT_DELAY_MSEC 0 40 41 /* 42 * Event information that we send to each subscriber is remembered in this 43 * struct. The event cannot be sent by simple UDP; it has to be sent by a HTTP 44 * over TCP transaction which requires various states.. It may also need to be 45 * retried at a different address (if more than one is available). 46 * 47 * TODO: As an optimization we could share data between subscribers. 48 */ 49 struct wps_event_ { 50 struct wps_event_ *next; 51 struct wps_event_ *prev; /* double linked list */ 52 struct subscription *s; /* parent */ 53 unsigned subscriber_sequence; /* which event for this subscription*/ 54 int retry; /* which retry */ 55 struct subscr_addr *addr; /* address to connect to */ 56 struct wpabuf *data; /* event data to send */ 57 /* The following apply while we are sending an event message. */ 58 int sd; /* -1 or socket descriptor for open connection */ 59 int sd_registered; /* nonzero if we must cancel registration */ 60 struct httpread *hread; /* NULL or open connection for event msg */ 61 }; 62 63 64 static void event_timeout_handler(void *eloop_data, void *user_ctx); 65 66 /* event_clean -- clean sockets etc. of event 67 * Leaves data, retry count etc. alone. 68 */ 69 static void event_clean(struct wps_event_ *e) 70 { 71 if (e->s->current_event == e) { 72 eloop_cancel_timeout(event_timeout_handler, NULL, e); 73 e->s->current_event = NULL; 74 } 75 if (e->sd_registered) { 76 eloop_unregister_sock(e->sd, EVENT_TYPE_WRITE); 77 e->sd_registered = 0; 78 } 79 if (e->sd != -1) { 80 close(e->sd); 81 e->sd = -1; 82 } 83 if (e->hread) 84 httpread_destroy(e->hread); 85 e->hread = NULL; 86 } 87 88 89 /* event_delete -- delete single unqueued event 90 * (be sure to dequeue first if need be) 91 */ 92 static void event_delete(struct wps_event_ *e) 93 { 94 event_clean(e); 95 wpabuf_free(e->data); 96 os_free(e); 97 } 98 99 100 /* event_dequeue -- get next event from the queue 101 * Returns NULL if empty. 102 */ 103 static struct wps_event_ *event_dequeue(struct subscription *s) 104 { 105 struct wps_event_ **event_head = &s->event_queue; 106 struct wps_event_ *e = *event_head; 107 if (e == NULL) 108 return NULL; 109 e->next->prev = e->prev; 110 e->prev->next = e->next; 111 if (*event_head == e) { 112 if (e == e->next) { 113 /* last in queue */ 114 *event_head = NULL; 115 } else { 116 *event_head = e->next; 117 } 118 } 119 s->n_queue--; 120 e->next = e->prev = NULL; 121 /* but parent "s" is still valid */ 122 return e; 123 } 124 125 126 /* event_enqueue_at_end -- add event to end of queue */ 127 static void event_enqueue_at_end(struct subscription *s, struct wps_event_ *e) 128 { 129 struct wps_event_ **event_head = &s->event_queue; 130 if (*event_head == NULL) { 131 *event_head = e->next = e->prev = e; 132 } else { 133 e->next = *event_head; 134 e->prev = e->next->prev; 135 e->prev->next = e; 136 e->next->prev = e; 137 } 138 s->n_queue++; 139 } 140 141 142 /* event_enqueue_at_begin -- add event to begin of queue 143 * (appropriate for retrying event only) 144 */ 145 static void event_enqueue_at_begin(struct subscription *s, 146 struct wps_event_ *e) 147 { 148 struct wps_event_ **event_head = &s->event_queue; 149 if (*event_head == NULL) { 150 *event_head = e->next = e->prev = e; 151 } else { 152 e->prev = *event_head; 153 e->next = e->prev->next; 154 e->prev->next = e; 155 e->next->prev = e; 156 *event_head = e; 157 } 158 s->n_queue++; 159 } 160 161 162 /* event_delete_all -- delete entire event queue and current event */ 163 void event_delete_all(struct subscription *s) 164 { 165 struct wps_event_ *e; 166 while ((e = event_dequeue(s)) != NULL) 167 event_delete(e); 168 if (s->current_event) { 169 event_delete(s->current_event); 170 /* will set: s->current_event = NULL; */ 171 } 172 } 173 174 175 /** 176 * event_retry - Called when we had a failure delivering event msg 177 * @e: Event 178 * @do_next_address: skip address e.g. on connect fail 179 */ 180 static void event_retry(struct wps_event_ *e, int do_next_address) 181 { 182 struct subscription *s = e->s; 183 struct upnp_wps_device_sm *sm = s->sm; 184 185 event_clean(e); 186 /* will set: s->current_event = NULL; */ 187 188 if (do_next_address) 189 e->retry++; 190 if (e->retry >= s->n_addr) { 191 wpa_printf(MSG_DEBUG, "WPS UPnP: Giving up on sending event " 192 "for %s", e->addr->domain_and_port); 193 return; 194 } 195 event_enqueue_at_begin(s, e); 196 event_send_all_later(sm); 197 } 198 199 200 /* called if the overall event-sending process takes too long */ 201 static void event_timeout_handler(void *eloop_data, void *user_ctx) 202 { 203 struct wps_event_ *e = user_ctx; 204 struct subscription *s = e->s; 205 206 assert(e == s->current_event); 207 208 wpa_printf(MSG_DEBUG, "WPS UPnP: Event send timeout"); 209 event_retry(e, 1); 210 } 211 212 213 /* event_got_response_handler -- called back when http response is received. */ 214 static void event_got_response_handler(struct httpread *handle, void *cookie, 215 enum httpread_event en) 216 { 217 struct wps_event_ *e = cookie; 218 struct subscription *s = e->s; 219 struct upnp_wps_device_sm *sm = s->sm; 220 struct httpread *hread = e->hread; 221 int reply_code = 0; 222 223 assert(e == s->current_event); 224 eloop_cancel_timeout(event_timeout_handler, NULL, e); 225 226 if (en == HTTPREAD_EVENT_FILE_READY) { 227 if (httpread_hdr_type_get(hread) == HTTPREAD_HDR_TYPE_REPLY) { 228 reply_code = httpread_reply_code_get(hread); 229 if (reply_code == HTTP_OK) { 230 wpa_printf(MSG_DEBUG, 231 "WPS UPnP: Got event reply OK from " 232 "%s", e->addr->domain_and_port); 233 event_delete(e); 234 goto send_more; 235 } else { 236 wpa_printf(MSG_DEBUG, "WPS UPnP: Got event " 237 "error reply code %d from %s", 238 reply_code, 239 e->addr->domain_and_port); 240 goto bad; 241 } 242 } else { 243 wpa_printf(MSG_DEBUG, "WPS UPnP: Got bogus event " 244 "response %d from %s", en, 245 e->addr->domain_and_port); 246 } 247 } else { 248 wpa_printf(MSG_DEBUG, "WPS UPnP: Event response timeout/fail " 249 "for %s", e->addr->domain_and_port); 250 goto bad; 251 } 252 event_retry(e, 1); 253 goto send_more; 254 255 send_more: 256 /* Schedule sending more if there is more to send */ 257 if (s->event_queue) 258 event_send_all_later(sm); 259 return; 260 261 bad: 262 /* 263 * If other side doesn't like what we say, forget about them. 264 * (There is no way to tell other side that we are dropping 265 * them...). 266 * Alternately, we could just do event_delete(e) 267 */ 268 wpa_printf(MSG_DEBUG, "WPS UPnP: Deleting subscription due to errors"); 269 subscription_unlink(s); 270 subscription_destroy(s); 271 } 272 273 274 /* event_send_tx_ready -- actually write event message 275 * 276 * Prequisite: subscription socket descriptor has become ready to 277 * write (because connection to subscriber has been made). 278 * 279 * It is also possible that we are called because the connect has failed; 280 * it is possible to test for this, or we can just go ahead and then 281 * the write will fail. 282 */ 283 static void event_send_tx_ready(int sock, void *eloop_ctx, void *sock_ctx) 284 { 285 struct wps_event_ *e = sock_ctx; 286 struct subscription *s = e->s; 287 struct wpabuf *buf; 288 char *b; 289 290 assert(e == s->current_event); 291 assert(e->sd == sock); 292 293 buf = wpabuf_alloc(1000 + wpabuf_len(e->data)); 294 if (buf == NULL) { 295 event_retry(e, 0); 296 goto bad; 297 } 298 wpabuf_printf(buf, "NOTIFY %s HTTP/1.1\r\n", e->addr->path); 299 wpabuf_put_str(buf, "SERVER: Unspecified, UPnP/1.0, Unspecified\r\n"); 300 wpabuf_printf(buf, "HOST: %s\r\n", e->addr->domain_and_port); 301 wpabuf_put_str(buf, "CONTENT-TYPE: text/xml; charset=\"utf-8\"\r\n" 302 "NT: upnp:event\r\n" 303 "NTS: upnp:propchange\r\n"); 304 wpabuf_put_str(buf, "SID: uuid:"); 305 b = wpabuf_put(buf, 0); 306 uuid_bin2str(s->uuid, b, 80); 307 wpabuf_put(buf, os_strlen(b)); 308 wpabuf_put_str(buf, "\r\n"); 309 wpabuf_printf(buf, "SEQ: %u\r\n", e->subscriber_sequence); 310 wpabuf_printf(buf, "CONTENT-LENGTH: %d\r\n", 311 (int) wpabuf_len(e->data)); 312 wpabuf_put_str(buf, "\r\n"); /* terminating empty line */ 313 wpabuf_put_buf(buf, e->data); 314 315 /* Since the message size is pretty small, we should be 316 * able to get the operating system to buffer what we give it 317 * and not have to come back again later to write more... 318 */ 319 #if 0 320 /* we could: Turn blocking back on? */ 321 fcntl(e->sd, F_SETFL, 0); 322 #endif 323 wpa_printf(MSG_DEBUG, "WPS UPnP: Sending event to %s", 324 e->addr->domain_and_port); 325 if (send_wpabuf(e->sd, buf) < 0) { 326 event_retry(e, 1); 327 goto bad; 328 } 329 wpabuf_free(buf); 330 buf = NULL; 331 332 if (e->sd_registered) { 333 e->sd_registered = 0; 334 eloop_unregister_sock(e->sd, EVENT_TYPE_WRITE); 335 } 336 /* Set up to read the reply */ 337 e->hread = httpread_create(e->sd, event_got_response_handler, 338 e /* cookie */, 339 0 /* no data expected */, 340 EVENT_TIMEOUT_SEC); 341 if (e->hread == NULL) { 342 wpa_printf(MSG_ERROR, "WPS UPnP: httpread_create failed"); 343 event_retry(e, 0); 344 goto bad; 345 } 346 return; 347 348 bad: 349 /* Schedule sending more if there is more to send */ 350 if (s->event_queue) 351 event_send_all_later(s->sm); 352 wpabuf_free(buf); 353 } 354 355 356 /* event_send_start -- prepare to send a event message to subscriber 357 * 358 * This gets complicated because: 359 * -- The message is sent via TCP and we have to keep the stream open 360 * for 30 seconds to get a response... then close it. 361 * -- But we might have other event happen in the meantime... 362 * we have to queue them, if we lose them then the subscriber will 363 * be forced to unsubscribe and subscribe again. 364 * -- If multiple URLs are provided then we are supposed to try successive 365 * ones after 30 second timeout. 366 * -- The URLs might use domain names instead of dotted decimal addresses, 367 * and resolution of those may cause unwanted sleeping. 368 * -- Doing the initial TCP connect can take a while, so we have to come 369 * back after connection and then send the data. 370 * 371 * Returns nonzero on error; 372 * 373 * Prerequisite: No current event send (s->current_event == NULL) 374 * and non-empty queue. 375 */ 376 static int event_send_start(struct subscription *s) 377 { 378 struct wps_event_ *e; 379 int itry; 380 381 /* 382 * Assume we are called ONLY with no current event and ONLY with 383 * nonempty event queue and ONLY with at least one address to send to. 384 */ 385 assert(s->addr_list != NULL); 386 assert(s->current_event == NULL); 387 assert(s->event_queue != NULL); 388 389 s->current_event = e = event_dequeue(s); 390 391 /* Use address acc. to no. of retries */ 392 e->addr = s->addr_list; 393 for (itry = 0; itry < e->retry; itry++) 394 e->addr = e->addr->next; 395 396 e->sd = socket(AF_INET, SOCK_STREAM, 0); 397 if (e->sd < 0) { 398 event_retry(e, 0); 399 return -1; 400 } 401 /* set non-blocking so we don't sleep waiting for connection */ 402 if (fcntl(e->sd, F_SETFL, O_NONBLOCK) != 0) { 403 event_retry(e, 0); 404 return -1; 405 } 406 /* 407 * Start the connect. It might succeed immediately but more likely will 408 * return errno EINPROGRESS. 409 */ 410 if (connect(e->sd, (struct sockaddr *) &e->addr->saddr, 411 sizeof(e->addr->saddr))) { 412 if (errno != EINPROGRESS) { 413 event_retry(e, 1); 414 return -1; 415 } 416 } 417 /* Call back when ready for writing (or on failure...). */ 418 if (eloop_register_sock(e->sd, EVENT_TYPE_WRITE, event_send_tx_ready, 419 NULL, e)) { 420 event_retry(e, 0); 421 return -1; 422 } 423 e->sd_registered = 1; 424 /* Don't wait forever! */ 425 if (eloop_register_timeout(EVENT_TIMEOUT_SEC, 0, event_timeout_handler, 426 NULL, e)) { 427 event_retry(e, 0); 428 return -1; 429 } 430 return 0; 431 } 432 433 434 /* event_send_all_later_handler -- actually send events as needed */ 435 static void event_send_all_later_handler(void *eloop_data, void *user_ctx) 436 { 437 struct upnp_wps_device_sm *sm = user_ctx; 438 struct subscription *s; 439 struct subscription *s_old; 440 int nerrors = 0; 441 442 sm->event_send_all_queued = 0; 443 s = sm->subscriptions; 444 if (s == NULL) 445 return; 446 do { 447 if (s->addr_list == NULL) { 448 /* if we've given up on all addresses */ 449 wpa_printf(MSG_DEBUG, "WPS UPnP: Removing " 450 "subscription with no addresses"); 451 s_old = s; 452 s = s_old->next; 453 subscription_unlink(s_old); 454 subscription_destroy(s_old); 455 } else { 456 if (s->current_event == NULL /* not busy */ && 457 s->event_queue != NULL /* more to do */) { 458 if (event_send_start(s)) 459 nerrors++; 460 } 461 s = s->next; 462 } 463 } while (sm->subscriptions != NULL && s != sm->subscriptions); 464 465 if (nerrors) { 466 /* Try again later */ 467 event_send_all_later(sm); 468 } 469 } 470 471 472 /* event_send_all_later -- schedule sending events to all subscribers 473 * that need it. 474 * This avoids two problems: 475 * -- After getting a subscription, we should not send the first event 476 * until after our reply is fully queued to be sent back, 477 * -- Possible stack depth or infinite recursion issues. 478 */ 479 void event_send_all_later(struct upnp_wps_device_sm *sm) 480 { 481 /* 482 * The exact time in the future isn't too important. Waiting a bit 483 * might let us do several together. 484 */ 485 if (sm->event_send_all_queued) 486 return; 487 sm->event_send_all_queued = 1; 488 eloop_register_timeout(EVENT_DELAY_SECONDS, EVENT_DELAY_MSEC, 489 event_send_all_later_handler, NULL, sm); 490 } 491 492 493 /* event_send_stop_all -- cleanup */ 494 void event_send_stop_all(struct upnp_wps_device_sm *sm) 495 { 496 if (sm->event_send_all_queued) 497 eloop_cancel_timeout(event_send_all_later_handler, NULL, sm); 498 sm->event_send_all_queued = 0; 499 } 500 501 502 /** 503 * event_add - Add a new event to a queue 504 * @s: Subscription 505 * @data: Event data (is copied; caller retains ownership) 506 * Returns: 0 on success, 1 on error 507 */ 508 int event_add(struct subscription *s, const struct wpabuf *data) 509 { 510 struct wps_event_ *e; 511 512 if (s->n_queue >= MAX_EVENTS_QUEUED) { 513 wpa_printf(MSG_DEBUG, "WPS UPnP: Too many events queued for " 514 "subscriber"); 515 return 1; 516 } 517 518 e = os_zalloc(sizeof(*e)); 519 if (e == NULL) 520 return 1; 521 e->s = s; 522 e->sd = -1; 523 e->data = wpabuf_dup(data); 524 if (e->data == NULL) { 525 os_free(e); 526 return 1; 527 } 528 e->subscriber_sequence = s->next_subscriber_sequence++; 529 if (s->next_subscriber_sequence == 0) 530 s->next_subscriber_sequence++; 531 event_enqueue_at_end(s, e); 532 event_send_all_later(s->sm); 533 return 0; 534 } 535