LCOV - code coverage report
Current view: top level - src/wps - wps_upnp_web.c (source / functions) Hit Total Coverage
Test: hostapd hwsim test run 1388943092 Lines: 388 537 72.3 %
Date: 2014-01-05 Functions: 19 20 95.0 %
Branches: 144 265 54.3 %

           Branch data     Line data    Source code
       1                 :            : /*
       2                 :            :  * UPnP WPS Device - Web connections
       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                 :            : 
      13                 :            : #include "common.h"
      14                 :            : #include "base64.h"
      15                 :            : #include "uuid.h"
      16                 :            : #include "httpread.h"
      17                 :            : #include "http_server.h"
      18                 :            : #include "wps_i.h"
      19                 :            : #include "wps_upnp.h"
      20                 :            : #include "wps_upnp_i.h"
      21                 :            : #include "upnp_xml.h"
      22                 :            : 
      23                 :            : /***************************************************************************
      24                 :            :  * Web connections (we serve pages of info about ourselves, handle
      25                 :            :  * requests, etc. etc.).
      26                 :            :  **************************************************************************/
      27                 :            : 
      28                 :            : #define WEB_CONNECTION_TIMEOUT_SEC 30   /* Drop web connection after t.o. */
      29                 :            : #define WEB_CONNECTION_MAX_READ 8000    /* Max we'll read for TCP request */
      30                 :            : #define MAX_WEB_CONNECTIONS 10          /* max simultaneous web connects */
      31                 :            : 
      32                 :            : 
      33                 :            : static const char *urn_wfawlanconfig =
      34                 :            :         "urn:schemas-wifialliance-org:service:WFAWLANConfig:1";
      35                 :            : static const char *http_server_hdr =
      36                 :            :         "Server: unspecified, UPnP/1.0, unspecified\r\n";
      37                 :            : static const char *http_connection_close =
      38                 :            :         "Connection: close\r\n";
      39                 :            : 
      40                 :            : /*
      41                 :            :  * "Files" that we serve via HTTP. The format of these files is given by
      42                 :            :  * WFA WPS specifications. Extra white space has been removed to save space.
      43                 :            :  */
      44                 :            : 
      45                 :            : static const char wps_scpd_xml[] =
      46                 :            : "<?xml version=\"1.0\"?>\n"
      47                 :            : "<scpd xmlns=\"urn:schemas-upnp-org:service-1-0\">\n"
      48                 :            : "<specVersion><major>1</major><minor>0</minor></specVersion>\n"
      49                 :            : "<actionList>\n"
      50                 :            : "<action>\n"
      51                 :            : "<name>GetDeviceInfo</name>\n"
      52                 :            : "<argumentList>\n"
      53                 :            : "<argument>\n"
      54                 :            : "<name>NewDeviceInfo</name>\n"
      55                 :            : "<direction>out</direction>\n"
      56                 :            : "<relatedStateVariable>DeviceInfo</relatedStateVariable>\n"
      57                 :            : "</argument>\n"
      58                 :            : "</argumentList>\n"
      59                 :            : "</action>\n"
      60                 :            : "<action>\n"
      61                 :            : "<name>PutMessage</name>\n"
      62                 :            : "<argumentList>\n"
      63                 :            : "<argument>\n"
      64                 :            : "<name>NewInMessage</name>\n"
      65                 :            : "<direction>in</direction>\n"
      66                 :            : "<relatedStateVariable>InMessage</relatedStateVariable>\n"
      67                 :            : "</argument>\n"
      68                 :            : "<argument>\n"
      69                 :            : "<name>NewOutMessage</name>\n"
      70                 :            : "<direction>out</direction>\n"
      71                 :            : "<relatedStateVariable>OutMessage</relatedStateVariable>\n"
      72                 :            : "</argument>\n"
      73                 :            : "</argumentList>\n"
      74                 :            : "</action>\n"
      75                 :            : "<action>\n"
      76                 :            : "<name>PutWLANResponse</name>\n"
      77                 :            : "<argumentList>\n"
      78                 :            : "<argument>\n"
      79                 :            : "<name>NewMessage</name>\n"
      80                 :            : "<direction>in</direction>\n"
      81                 :            : "<relatedStateVariable>Message</relatedStateVariable>\n"
      82                 :            : "</argument>\n"
      83                 :            : "<argument>\n"
      84                 :            : "<name>NewWLANEventType</name>\n"
      85                 :            : "<direction>in</direction>\n"
      86                 :            : "<relatedStateVariable>WLANEventType</relatedStateVariable>\n"
      87                 :            : "</argument>\n"
      88                 :            : "<argument>\n"
      89                 :            : "<name>NewWLANEventMAC</name>\n"
      90                 :            : "<direction>in</direction>\n"
      91                 :            : "<relatedStateVariable>WLANEventMAC</relatedStateVariable>\n"
      92                 :            : "</argument>\n"
      93                 :            : "</argumentList>\n"
      94                 :            : "</action>\n"
      95                 :            : "<action>\n"
      96                 :            : "<name>SetSelectedRegistrar</name>\n"
      97                 :            : "<argumentList>\n"
      98                 :            : "<argument>\n"
      99                 :            : "<name>NewMessage</name>\n"
     100                 :            : "<direction>in</direction>\n"
     101                 :            : "<relatedStateVariable>Message</relatedStateVariable>\n"
     102                 :            : "</argument>\n"
     103                 :            : "</argumentList>\n"
     104                 :            : "</action>\n"
     105                 :            : "</actionList>\n"
     106                 :            : "<serviceStateTable>\n"
     107                 :            : "<stateVariable sendEvents=\"no\">\n"
     108                 :            : "<name>Message</name>\n"
     109                 :            : "<dataType>bin.base64</dataType>\n"
     110                 :            : "</stateVariable>\n"
     111                 :            : "<stateVariable sendEvents=\"no\">\n"
     112                 :            : "<name>InMessage</name>\n"
     113                 :            : "<dataType>bin.base64</dataType>\n"
     114                 :            : "</stateVariable>\n"
     115                 :            : "<stateVariable sendEvents=\"no\">\n"
     116                 :            : "<name>OutMessage</name>\n"
     117                 :            : "<dataType>bin.base64</dataType>\n"
     118                 :            : "</stateVariable>\n"
     119                 :            : "<stateVariable sendEvents=\"no\">\n"
     120                 :            : "<name>DeviceInfo</name>\n"
     121                 :            : "<dataType>bin.base64</dataType>\n"
     122                 :            : "</stateVariable>\n"
     123                 :            : "<stateVariable sendEvents=\"yes\">\n"
     124                 :            : "<name>APStatus</name>\n"
     125                 :            : "<dataType>ui1</dataType>\n"
     126                 :            : "</stateVariable>\n"
     127                 :            : "<stateVariable sendEvents=\"yes\">\n"
     128                 :            : "<name>STAStatus</name>\n"
     129                 :            : "<dataType>ui1</dataType>\n"
     130                 :            : "</stateVariable>\n"
     131                 :            : "<stateVariable sendEvents=\"yes\">\n"
     132                 :            : "<name>WLANEvent</name>\n"
     133                 :            : "<dataType>bin.base64</dataType>\n"
     134                 :            : "</stateVariable>\n"
     135                 :            : "<stateVariable sendEvents=\"no\">\n"
     136                 :            : "<name>WLANEventType</name>\n"
     137                 :            : "<dataType>ui1</dataType>\n"
     138                 :            : "</stateVariable>\n"
     139                 :            : "<stateVariable sendEvents=\"no\">\n"
     140                 :            : "<name>WLANEventMAC</name>\n"
     141                 :            : "<dataType>string</dataType>\n"
     142                 :            : "</stateVariable>\n"
     143                 :            : "<stateVariable sendEvents=\"no\">\n"
     144                 :            : "<name>WLANResponse</name>\n"
     145                 :            : "<dataType>bin.base64</dataType>\n"
     146                 :            : "</stateVariable>\n"
     147                 :            : "</serviceStateTable>\n"
     148                 :            : "</scpd>\n"
     149                 :            : ;
     150                 :            : 
     151                 :            : 
     152                 :            : static const char *wps_device_xml_prefix =
     153                 :            :         "<?xml version=\"1.0\"?>\n"
     154                 :            :         "<root xmlns=\"urn:schemas-upnp-org:device-1-0\">\n"
     155                 :            :         "<specVersion>\n"
     156                 :            :         "<major>1</major>\n"
     157                 :            :         "<minor>0</minor>\n"
     158                 :            :         "</specVersion>\n"
     159                 :            :         "<device>\n"
     160                 :            :         "<deviceType>urn:schemas-wifialliance-org:device:WFADevice:1"
     161                 :            :         "</deviceType>\n";
     162                 :            : 
     163                 :            : static const char *wps_device_xml_postfix =
     164                 :            :         "<serviceList>\n"
     165                 :            :         "<service>\n"
     166                 :            :         "<serviceType>urn:schemas-wifialliance-org:service:WFAWLANConfig:1"
     167                 :            :         "</serviceType>\n"
     168                 :            :         "<serviceId>urn:wifialliance-org:serviceId:WFAWLANConfig1</serviceId>"
     169                 :            :         "\n"
     170                 :            :         "<SCPDURL>" UPNP_WPS_SCPD_XML_FILE "</SCPDURL>\n"
     171                 :            :         "<controlURL>" UPNP_WPS_DEVICE_CONTROL_FILE "</controlURL>\n"
     172                 :            :         "<eventSubURL>" UPNP_WPS_DEVICE_EVENT_FILE "</eventSubURL>\n"
     173                 :            :         "</service>\n"
     174                 :            :         "</serviceList>\n"
     175                 :            :         "</device>\n"
     176                 :            :         "</root>\n";
     177                 :            : 
     178                 :            : 
     179                 :            : /* format_wps_device_xml -- produce content of "file" wps_device.xml
     180                 :            :  * (UPNP_WPS_DEVICE_XML_FILE)
     181                 :            :  */
     182                 :          4 : static void format_wps_device_xml(struct upnp_wps_device_sm *sm,
     183                 :            :                                   struct wpabuf *buf)
     184                 :            : {
     185                 :            :         const char *s;
     186                 :            :         char uuid_string[80];
     187                 :            :         struct upnp_wps_device_interface *iface;
     188                 :            : 
     189         [ +  - ]:          4 :         iface = dl_list_first(&sm->interfaces,
     190                 :            :                               struct upnp_wps_device_interface, list);
     191                 :            : 
     192                 :          4 :         wpabuf_put_str(buf, wps_device_xml_prefix);
     193                 :            : 
     194                 :            :         /*
     195                 :            :          * Add required fields with default values if not configured. Add
     196                 :            :          * optional and recommended fields only if configured.
     197                 :            :          */
     198                 :          4 :         s = iface->wps->friendly_name;
     199 [ -  + ][ #  # ]:          4 :         s = ((s && *s) ? s : "WPS Access Point");
     200                 :          4 :         xml_add_tagged_data(buf, "friendlyName", s);
     201                 :            : 
     202                 :          4 :         s = iface->wps->dev.manufacturer;
     203 [ +  - ][ +  - ]:          4 :         s = ((s && *s) ? s : "");
     204                 :          4 :         xml_add_tagged_data(buf, "manufacturer", s);
     205                 :            : 
     206         [ -  + ]:          4 :         if (iface->wps->manufacturer_url)
     207                 :          0 :                 xml_add_tagged_data(buf, "manufacturerURL",
     208                 :          0 :                                     iface->wps->manufacturer_url);
     209                 :            : 
     210         [ -  + ]:          4 :         if (iface->wps->model_description)
     211                 :          0 :                 xml_add_tagged_data(buf, "modelDescription",
     212                 :          0 :                                     iface->wps->model_description);
     213                 :            : 
     214                 :          4 :         s = iface->wps->dev.model_name;
     215 [ +  - ][ +  - ]:          4 :         s = ((s && *s) ? s : "");
     216                 :          4 :         xml_add_tagged_data(buf, "modelName", s);
     217                 :            : 
     218         [ +  - ]:          4 :         if (iface->wps->dev.model_number)
     219                 :          4 :                 xml_add_tagged_data(buf, "modelNumber",
     220                 :          4 :                                     iface->wps->dev.model_number);
     221                 :            : 
     222         [ -  + ]:          4 :         if (iface->wps->model_url)
     223                 :          0 :                 xml_add_tagged_data(buf, "modelURL", iface->wps->model_url);
     224                 :            : 
     225         [ +  - ]:          4 :         if (iface->wps->dev.serial_number)
     226                 :          4 :                 xml_add_tagged_data(buf, "serialNumber",
     227                 :          4 :                                     iface->wps->dev.serial_number);
     228                 :            : 
     229                 :          4 :         uuid_bin2str(iface->wps->uuid, uuid_string, sizeof(uuid_string));
     230                 :          4 :         s = uuid_string;
     231                 :            :         /* Need "uuid:" prefix, thus we can't use xml_add_tagged_data()
     232                 :            :          * easily...
     233                 :            :          */
     234                 :          4 :         wpabuf_put_str(buf, "<UDN>uuid:");
     235                 :          4 :         xml_data_encode(buf, s, os_strlen(s));
     236                 :          4 :         wpabuf_put_str(buf, "</UDN>\n");
     237                 :            : 
     238         [ -  + ]:          4 :         if (iface->wps->upc)
     239                 :          0 :                 xml_add_tagged_data(buf, "UPC", iface->wps->upc);
     240                 :            : 
     241                 :          4 :         wpabuf_put_str(buf, wps_device_xml_postfix);
     242                 :          4 : }
     243                 :            : 
     244                 :            : 
     245                 :          5 : static void http_put_reply_code(struct wpabuf *buf, enum http_reply_code code)
     246                 :            : {
     247                 :          5 :         wpabuf_put_str(buf, "HTTP/1.1 ");
     248   [ +  -  -  -  :          5 :         switch (code) {
                      - ]
     249                 :            :         case HTTP_OK:
     250                 :          5 :                 wpabuf_put_str(buf, "200 OK\r\n");
     251                 :          5 :                 break;
     252                 :            :         case HTTP_BAD_REQUEST:
     253                 :          0 :                 wpabuf_put_str(buf, "400 Bad request\r\n");
     254                 :          0 :                 break;
     255                 :            :         case HTTP_PRECONDITION_FAILED:
     256                 :          0 :                 wpabuf_put_str(buf, "412 Precondition failed\r\n");
     257                 :          0 :                 break;
     258                 :            :         case HTTP_UNIMPLEMENTED:
     259                 :          0 :                 wpabuf_put_str(buf, "501 Unimplemented\r\n");
     260                 :          0 :                 break;
     261                 :            :         case HTTP_INTERNAL_SERVER_ERROR:
     262                 :            :         default:
     263                 :          0 :                 wpabuf_put_str(buf, "500 Internal server error\r\n");
     264                 :          0 :                 break;
     265                 :            :         }
     266                 :          5 : }
     267                 :            : 
     268                 :            : 
     269                 :         38 : static void http_put_date(struct wpabuf *buf)
     270                 :            : {
     271                 :         38 :         wpabuf_put_str(buf, "Date: ");
     272                 :         38 :         format_date(buf);
     273                 :         38 :         wpabuf_put_str(buf, "\r\n");
     274                 :         38 : }
     275                 :            : 
     276                 :            : 
     277                 :          1 : static void http_put_empty(struct wpabuf *buf, enum http_reply_code code)
     278                 :            : {
     279                 :          1 :         http_put_reply_code(buf, code);
     280                 :          1 :         wpabuf_put_str(buf, http_server_hdr);
     281                 :          1 :         wpabuf_put_str(buf, http_connection_close);
     282                 :          1 :         wpabuf_put_str(buf, "Content-Length: 0\r\n"
     283                 :            :                        "\r\n");
     284                 :          1 : }
     285                 :            : 
     286                 :            : 
     287                 :            : /* Given that we have received a header w/ GET, act upon it
     288                 :            :  *
     289                 :            :  * Format of GET (case-insensitive):
     290                 :            :  *
     291                 :            :  * First line must be:
     292                 :            :  *      GET /<file> HTTP/1.1
     293                 :            :  * Since we don't do anything fancy we just ignore other lines.
     294                 :            :  *
     295                 :            :  * Our response (if no error) which includes only required lines is:
     296                 :            :  * HTTP/1.1 200 OK
     297                 :            :  * Connection: close
     298                 :            :  * Content-Type: text/xml
     299                 :            :  * Date: <rfc1123-date>
     300                 :            :  *
     301                 :            :  * Header lines must end with \r\n
     302                 :            :  * Per RFC 2616, content-length: is not required but connection:close
     303                 :            :  * would appear to be required (given that we will be closing it!).
     304                 :            :  */
     305                 :          4 : static void web_connection_parse_get(struct upnp_wps_device_sm *sm,
     306                 :            :                                      struct http_request *hreq, char *filename)
     307                 :            : {
     308                 :            :         struct wpabuf *buf; /* output buffer, allocated */
     309                 :            :         char *put_length_here;
     310                 :            :         char *body_start;
     311                 :            :         enum {
     312                 :            :                 GET_DEVICE_XML_FILE,
     313                 :            :                 GET_SCPD_XML_FILE
     314                 :            :         } req;
     315                 :          4 :         size_t extra_len = 0;
     316                 :            :         int body_length;
     317                 :            :         char len_buf[10];
     318                 :            :         struct upnp_wps_device_interface *iface;
     319                 :            : 
     320         [ +  - ]:          4 :         iface = dl_list_first(&sm->interfaces,
     321                 :            :                               struct upnp_wps_device_interface, list);
     322                 :            : 
     323                 :            :         /*
     324                 :            :          * It is not required that filenames be case insensitive but it is
     325                 :            :          * allowed and cannot hurt here.
     326                 :            :          */
     327         [ -  + ]:          4 :         if (filename == NULL)
     328                 :          0 :                 filename = "(null)"; /* just in case */
     329         [ +  - ]:          4 :         if (os_strcasecmp(filename, UPNP_WPS_DEVICE_XML_FILE) == 0) {
     330                 :          4 :                 wpa_printf(MSG_DEBUG, "WPS UPnP: HTTP GET for device XML");
     331                 :          4 :                 req = GET_DEVICE_XML_FILE;
     332                 :          4 :                 extra_len = 3000;
     333         [ -  + ]:          4 :                 if (iface->wps->friendly_name)
     334                 :          0 :                         extra_len += os_strlen(iface->wps->friendly_name);
     335         [ -  + ]:          4 :                 if (iface->wps->manufacturer_url)
     336                 :          0 :                         extra_len += os_strlen(iface->wps->manufacturer_url);
     337         [ -  + ]:          4 :                 if (iface->wps->model_description)
     338                 :          0 :                         extra_len += os_strlen(iface->wps->model_description);
     339         [ -  + ]:          4 :                 if (iface->wps->model_url)
     340                 :          0 :                         extra_len += os_strlen(iface->wps->model_url);
     341         [ -  + ]:          4 :                 if (iface->wps->upc)
     342                 :          0 :                         extra_len += os_strlen(iface->wps->upc);
     343         [ #  # ]:          0 :         } else if (!os_strcasecmp(filename, UPNP_WPS_SCPD_XML_FILE)) {
     344                 :          0 :                 wpa_printf(MSG_DEBUG, "WPS UPnP: HTTP GET for SCPD XML");
     345                 :          0 :                 req = GET_SCPD_XML_FILE;
     346                 :          0 :                 extra_len = os_strlen(wps_scpd_xml);
     347                 :            :         } else {
     348                 :            :                 /* File not found */
     349                 :          0 :                 wpa_printf(MSG_DEBUG, "WPS UPnP: HTTP GET file not found: %s",
     350                 :            :                            filename);
     351                 :          0 :                 buf = wpabuf_alloc(200);
     352         [ #  # ]:          0 :                 if (buf == NULL) {
     353                 :          0 :                         http_request_deinit(hreq);
     354                 :          0 :                         return;
     355                 :            :                 }
     356                 :          0 :                 wpabuf_put_str(buf,
     357                 :            :                                "HTTP/1.1 404 Not Found\r\n"
     358                 :            :                                "Connection: close\r\n");
     359                 :            : 
     360                 :          0 :                 http_put_date(buf);
     361                 :            : 
     362                 :            :                 /* terminating empty line */
     363                 :          0 :                 wpabuf_put_str(buf, "\r\n");
     364                 :            : 
     365                 :          0 :                 goto send_buf;
     366                 :            :         }
     367                 :            : 
     368                 :          4 :         buf = wpabuf_alloc(1000 + extra_len);
     369         [ -  + ]:          4 :         if (buf == NULL) {
     370                 :          0 :                 http_request_deinit(hreq);
     371                 :          0 :                 return;
     372                 :            :         }
     373                 :            : 
     374                 :          4 :         wpabuf_put_str(buf,
     375                 :            :                        "HTTP/1.1 200 OK\r\n"
     376                 :            :                        "Content-Type: text/xml; charset=\"utf-8\"\r\n");
     377                 :          4 :         wpabuf_put_str(buf, "Server: Unspecified, UPnP/1.0, Unspecified\r\n");
     378                 :          4 :         wpabuf_put_str(buf, "Connection: close\r\n");
     379                 :          4 :         wpabuf_put_str(buf, "Content-Length: ");
     380                 :            :         /*
     381                 :            :          * We will paste the length in later, leaving some extra whitespace.
     382                 :            :          * HTTP code is supposed to be tolerant of extra whitespace.
     383                 :            :          */
     384                 :          4 :         put_length_here = wpabuf_put(buf, 0);
     385                 :          4 :         wpabuf_put_str(buf, "        \r\n");
     386                 :            : 
     387                 :          4 :         http_put_date(buf);
     388                 :            : 
     389                 :            :         /* terminating empty line */
     390                 :          4 :         wpabuf_put_str(buf, "\r\n");
     391                 :            : 
     392                 :          4 :         body_start = wpabuf_put(buf, 0);
     393                 :            : 
     394      [ +  -  - ]:          4 :         switch (req) {
     395                 :            :         case GET_DEVICE_XML_FILE:
     396                 :          4 :                 format_wps_device_xml(sm, buf);
     397                 :          4 :                 break;
     398                 :            :         case GET_SCPD_XML_FILE:
     399                 :          0 :                 wpabuf_put_str(buf, wps_scpd_xml);
     400                 :          0 :                 break;
     401                 :            :         }
     402                 :            : 
     403                 :            :         /* Now patch in the content length at the end */
     404                 :          4 :         body_length = (char *) wpabuf_put(buf, 0) - body_start;
     405                 :          4 :         os_snprintf(len_buf, 10, "%d", body_length);
     406                 :          4 :         os_memcpy(put_length_here, len_buf, os_strlen(len_buf));
     407                 :            : 
     408                 :            : send_buf:
     409                 :          4 :         http_request_send_and_deinit(hreq, buf);
     410                 :            : }
     411                 :            : 
     412                 :            : 
     413                 :            : static enum http_reply_code
     414                 :          6 : web_process_get_device_info(struct upnp_wps_device_sm *sm,
     415                 :            :                             struct wpabuf **reply, const char **replyname)
     416                 :            : {
     417                 :            :         static const char *name = "NewDeviceInfo";
     418                 :            :         struct wps_config cfg;
     419                 :            :         struct upnp_wps_device_interface *iface;
     420                 :            :         struct upnp_wps_peer *peer;
     421                 :            : 
     422         [ +  - ]:          6 :         iface = dl_list_first(&sm->interfaces,
     423                 :            :                               struct upnp_wps_device_interface, list);
     424                 :          6 :         peer = &iface->peer;
     425                 :            : 
     426                 :          6 :         wpa_printf(MSG_DEBUG, "WPS UPnP: GetDeviceInfo");
     427                 :            : 
     428         [ -  + ]:          6 :         if (iface->ctx->ap_pin == NULL)
     429                 :          0 :                 return HTTP_INTERNAL_SERVER_ERROR;
     430                 :            : 
     431                 :            :         /*
     432                 :            :          * Request for DeviceInfo, i.e., M1 TLVs. This is a start of WPS
     433                 :            :          * registration over UPnP with the AP acting as an Enrollee. It should
     434                 :            :          * be noted that this is frequently used just to get the device data,
     435                 :            :          * i.e., there may not be any intent to actually complete the
     436                 :            :          * registration.
     437                 :            :          */
     438                 :            : 
     439         [ +  + ]:          6 :         if (peer->wps)
     440                 :          2 :                 wps_deinit(peer->wps);
     441                 :            : 
     442                 :          6 :         os_memset(&cfg, 0, sizeof(cfg));
     443                 :          6 :         cfg.wps = iface->wps;
     444                 :          6 :         cfg.pin = (u8 *) iface->ctx->ap_pin;
     445                 :          6 :         cfg.pin_len = os_strlen(iface->ctx->ap_pin);
     446                 :          6 :         peer->wps = wps_init(&cfg);
     447         [ +  - ]:          6 :         if (peer->wps) {
     448                 :            :                 enum wsc_op_code op_code;
     449                 :          6 :                 *reply = wps_get_msg(peer->wps, &op_code);
     450         [ -  + ]:          6 :                 if (*reply == NULL) {
     451                 :          0 :                         wps_deinit(peer->wps);
     452                 :          0 :                         peer->wps = NULL;
     453                 :            :                 }
     454                 :            :         } else
     455                 :          0 :                 *reply = NULL;
     456         [ -  + ]:          6 :         if (*reply == NULL) {
     457                 :          0 :                 wpa_printf(MSG_INFO, "WPS UPnP: Failed to get DeviceInfo");
     458                 :          0 :                 return HTTP_INTERNAL_SERVER_ERROR;
     459                 :            :         }
     460                 :          6 :         *replyname = name;
     461                 :          6 :         return HTTP_OK;
     462                 :            : }
     463                 :            : 
     464                 :            : 
     465                 :            : static enum http_reply_code
     466                 :          8 : web_process_put_message(struct upnp_wps_device_sm *sm, char *data,
     467                 :            :                         struct wpabuf **reply, const char **replyname)
     468                 :            : {
     469                 :            :         struct wpabuf *msg;
     470                 :            :         static const char *name = "NewOutMessage";
     471                 :            :         enum http_reply_code ret;
     472                 :            :         enum wps_process_res res;
     473                 :            :         enum wsc_op_code op_code;
     474                 :            :         struct upnp_wps_device_interface *iface;
     475                 :            : 
     476         [ +  - ]:          8 :         iface = dl_list_first(&sm->interfaces,
     477                 :            :                               struct upnp_wps_device_interface, list);
     478                 :            : 
     479                 :            :         /*
     480                 :            :          * PutMessage is used by external UPnP-based Registrar to perform WPS
     481                 :            :          * operation with the access point itself; as compared with
     482                 :            :          * PutWLANResponse which is for proxying.
     483                 :            :          */
     484                 :          8 :         wpa_printf(MSG_DEBUG, "WPS UPnP: PutMessage");
     485                 :          8 :         msg = xml_get_base64_item(data, "NewInMessage", &ret);
     486         [ -  + ]:          8 :         if (msg == NULL)
     487                 :          0 :                 return ret;
     488                 :          8 :         res = wps_process_msg(iface->peer.wps, WSC_UPnP, msg);
     489         [ +  + ]:          8 :         if (res == WPS_FAILURE)
     490                 :          1 :                 *reply = NULL;
     491                 :            :         else
     492                 :          7 :                 *reply = wps_get_msg(iface->peer.wps, &op_code);
     493                 :          8 :         wpabuf_free(msg);
     494         [ +  + ]:          8 :         if (*reply == NULL)
     495                 :          1 :                 return HTTP_INTERNAL_SERVER_ERROR;
     496                 :          7 :         *replyname = name;
     497                 :          8 :         return HTTP_OK;
     498                 :            : }
     499                 :            : 
     500                 :            : 
     501                 :            : static enum http_reply_code
     502                 :          8 : web_process_put_wlan_response(struct upnp_wps_device_sm *sm, char *data,
     503                 :            :                               struct wpabuf **reply, const char **replyname)
     504                 :            : {
     505                 :            :         struct wpabuf *msg;
     506                 :            :         enum http_reply_code ret;
     507                 :            :         u8 macaddr[ETH_ALEN];
     508                 :            :         int ev_type;
     509                 :            :         int type;
     510                 :            :         char *val;
     511                 :            :         struct upnp_wps_device_interface *iface;
     512                 :          8 :         int ok = 0;
     513                 :            : 
     514                 :            :         /*
     515                 :            :          * External UPnP-based Registrar is passing us a message to be proxied
     516                 :            :          * over to a Wi-Fi -based client of ours.
     517                 :            :          */
     518                 :            : 
     519                 :          8 :         wpa_printf(MSG_DEBUG, "WPS UPnP: PutWLANResponse");
     520                 :          8 :         msg = xml_get_base64_item(data, "NewMessage", &ret);
     521         [ -  + ]:          8 :         if (msg == NULL) {
     522                 :          0 :                 wpa_printf(MSG_DEBUG, "WPS UPnP: Could not extract NewMessage "
     523                 :            :                            "from PutWLANResponse");
     524                 :          0 :                 return ret;
     525                 :            :         }
     526                 :          8 :         val = xml_get_first_item(data, "NewWLANEventType");
     527         [ -  + ]:          8 :         if (val == NULL) {
     528                 :          0 :                 wpa_printf(MSG_DEBUG, "WPS UPnP: No NewWLANEventType in "
     529                 :            :                            "PutWLANResponse");
     530                 :          0 :                 wpabuf_free(msg);
     531                 :          0 :                 return UPNP_ARG_VALUE_INVALID;
     532                 :            :         }
     533                 :          8 :         ev_type = atol(val);
     534                 :          8 :         os_free(val);
     535                 :          8 :         val = xml_get_first_item(data, "NewWLANEventMAC");
     536         [ -  + ]:          8 :         if (val == NULL) {
     537                 :          0 :                 wpa_printf(MSG_DEBUG, "WPS UPnP: No NewWLANEventMAC in "
     538                 :            :                            "PutWLANResponse");
     539                 :          0 :                 wpabuf_free(msg);
     540                 :          0 :                 return UPNP_ARG_VALUE_INVALID;
     541                 :            :         }
     542         [ -  + ]:          8 :         if (hwaddr_aton(val, macaddr)) {
     543                 :          0 :                 wpa_printf(MSG_DEBUG, "WPS UPnP: Invalid NewWLANEventMAC in "
     544                 :            :                            "PutWLANResponse: '%s'", val);
     545                 :            : #ifdef CONFIG_WPS_STRICT
     546                 :            :                 {
     547                 :            :                         struct wps_parse_attr attr;
     548                 :            :                         if (wps_parse_msg(msg, &attr) < 0 || attr.version2) {
     549                 :            :                                 wpabuf_free(msg);
     550                 :            :                                 os_free(val);
     551                 :            :                                 return UPNP_ARG_VALUE_INVALID;
     552                 :            :                         }
     553                 :            :                 }
     554                 :            : #endif /* CONFIG_WPS_STRICT */
     555         [ #  # ]:          0 :                 if (hwaddr_aton2(val, macaddr) > 0) {
     556                 :            :                         /*
     557                 :            :                          * At least some versions of Intel PROset seem to be
     558                 :            :                          * using dot-deliminated MAC address format here.
     559                 :            :                          */
     560                 :          0 :                         wpa_printf(MSG_DEBUG, "WPS UPnP: Workaround - allow "
     561                 :            :                                    "incorrect MAC address format in "
     562                 :            :                                    "NewWLANEventMAC: %s -> " MACSTR,
     563                 :          0 :                                    val, MAC2STR(macaddr));
     564                 :            :                 } else {
     565                 :          0 :                         wpabuf_free(msg);
     566                 :          0 :                         os_free(val);
     567                 :          0 :                         return UPNP_ARG_VALUE_INVALID;
     568                 :            :                 }
     569                 :            :         }
     570                 :          8 :         os_free(val);
     571         [ +  - ]:          8 :         if (ev_type == UPNP_WPS_WLANEVENT_TYPE_EAP) {
     572                 :            :                 struct wps_parse_attr attr;
     573 [ +  - ][ -  + ]:          8 :                 if (wps_parse_msg(msg, &attr) < 0 ||
     574                 :          8 :                     attr.msg_type == NULL)
     575                 :          0 :                         type = -1;
     576                 :            :                 else
     577                 :          8 :                         type = *attr.msg_type;
     578                 :          8 :                 wpa_printf(MSG_DEBUG, "WPS UPnP: Message Type %d", type);
     579                 :            :         } else
     580                 :          0 :                 type = -1;
     581         [ +  + ]:         16 :         dl_list_for_each(iface, &sm->interfaces,
     582                 :            :                          struct upnp_wps_device_interface, list) {
     583   [ +  -  +  - ]:         16 :                 if (iface->ctx->rx_req_put_wlan_response &&
     584                 :          8 :                     iface->ctx->rx_req_put_wlan_response(iface->priv, ev_type,
     585                 :            :                                                          macaddr, msg, type)
     586                 :            :                     == 0)
     587                 :          8 :                         ok = 1;
     588                 :            :         }
     589                 :            : 
     590         [ -  + ]:          8 :         if (!ok) {
     591                 :          0 :                 wpa_printf(MSG_INFO, "WPS UPnP: Fail: sm->ctx->"
     592                 :            :                            "rx_req_put_wlan_response");
     593                 :          0 :                 wpabuf_free(msg);
     594                 :          0 :                 return HTTP_INTERNAL_SERVER_ERROR;
     595                 :            :         }
     596                 :          8 :         wpabuf_free(msg);
     597                 :          8 :         *replyname = NULL;
     598                 :          8 :         *reply = NULL;
     599                 :          8 :         return HTTP_OK;
     600                 :            : }
     601                 :            : 
     602                 :            : 
     603                 :          8 : static int find_er_addr(struct subscription *s, struct sockaddr_in *cli)
     604                 :            : {
     605                 :            :         struct subscr_addr *a;
     606                 :            : 
     607         [ +  - ]:          8 :         dl_list_for_each(a, &s->addr_list, struct subscr_addr, list) {
     608         [ +  - ]:          8 :                 if (cli->sin_addr.s_addr == a->saddr.sin_addr.s_addr)
     609                 :          8 :                         return 1;
     610                 :            :         }
     611                 :          8 :         return 0;
     612                 :            : }
     613                 :            : 
     614                 :            : 
     615                 :          8 : static struct subscription * find_er(struct upnp_wps_device_sm *sm,
     616                 :            :                                      struct sockaddr_in *cli)
     617                 :            : {
     618                 :            :         struct subscription *s;
     619         [ +  - ]:          8 :         dl_list_for_each(s, &sm->subscriptions, struct subscription, list)
     620         [ +  - ]:          8 :                 if (find_er_addr(s, cli))
     621                 :          8 :                         return s;
     622                 :          8 :         return NULL;
     623                 :            : }
     624                 :            : 
     625                 :            : 
     626                 :            : static enum http_reply_code
     627                 :          8 : web_process_set_selected_registrar(struct upnp_wps_device_sm *sm,
     628                 :            :                                    struct sockaddr_in *cli, char *data,
     629                 :            :                                    struct wpabuf **reply,
     630                 :            :                                    const char **replyname)
     631                 :            : {
     632                 :            :         struct wpabuf *msg;
     633                 :            :         enum http_reply_code ret;
     634                 :            :         struct subscription *s;
     635                 :            :         struct upnp_wps_device_interface *iface;
     636                 :          8 :         int err = 0;
     637                 :            : 
     638                 :          8 :         wpa_printf(MSG_DEBUG, "WPS UPnP: SetSelectedRegistrar");
     639                 :          8 :         s = find_er(sm, cli);
     640         [ -  + ]:          8 :         if (s == NULL) {
     641                 :          0 :                 wpa_printf(MSG_DEBUG, "WPS UPnP: Ignore SetSelectedRegistrar "
     642                 :            :                            "from unknown ER");
     643                 :          0 :                 return UPNP_ACTION_FAILED;
     644                 :            :         }
     645                 :          8 :         msg = xml_get_base64_item(data, "NewMessage", &ret);
     646         [ -  + ]:          8 :         if (msg == NULL)
     647                 :          0 :                 return ret;
     648         [ +  + ]:         16 :         dl_list_for_each(iface, &sm->interfaces,
     649                 :            :                          struct upnp_wps_device_interface, list) {
     650         [ -  + ]:          8 :                 if (upnp_er_set_selected_registrar(iface->wps->registrar, s,
     651                 :            :                                                    msg))
     652                 :          0 :                         err = 1;
     653                 :            :         }
     654                 :          8 :         wpabuf_free(msg);
     655         [ -  + ]:          8 :         if (err)
     656                 :          0 :                 return HTTP_INTERNAL_SERVER_ERROR;
     657                 :          8 :         *replyname = NULL;
     658                 :          8 :         *reply = NULL;
     659                 :          8 :         return HTTP_OK;
     660                 :            : }
     661                 :            : 
     662                 :            : 
     663                 :            : static const char *soap_prefix =
     664                 :            :         "<?xml version=\"1.0\"?>\n"
     665                 :            :         "<s:Envelope xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\" "
     666                 :            :         "s:encodingStyle=\"http://schemas.xmlsoap.org/soap/encoding/\">\n"
     667                 :            :         "<s:Body>\n";
     668                 :            : static const char *soap_postfix =
     669                 :            :         "</s:Body>\n</s:Envelope>\n";
     670                 :            : 
     671                 :            : static const char *soap_error_prefix =
     672                 :            :         "<s:Fault>\n"
     673                 :            :         "<faultcode>s:Client</faultcode>\n"
     674                 :            :         "<faultstring>UPnPError</faultstring>\n"
     675                 :            :         "<detail>\n"
     676                 :            :         "<UPnPError xmlns=\"urn:schemas-upnp-org:control-1-0\">\n";
     677                 :            : static const char *soap_error_postfix =
     678                 :            :         "<errorDescription>Error</errorDescription>\n"
     679                 :            :         "</UPnPError>\n"
     680                 :            :         "</detail>\n"
     681                 :            :         "</s:Fault>\n";
     682                 :            : 
     683                 :         30 : static void web_connection_send_reply(struct http_request *req,
     684                 :            :                                       enum http_reply_code ret,
     685                 :            :                                       const char *action, int action_len,
     686                 :            :                                       const struct wpabuf *reply,
     687                 :            :                                       const char *replyname)
     688                 :            : {
     689                 :            :         struct wpabuf *buf;
     690                 :            :         char *replydata;
     691                 :         30 :         char *put_length_here = NULL;
     692                 :         30 :         char *body_start = NULL;
     693                 :            : 
     694         [ +  + ]:         30 :         if (reply) {
     695                 :            :                 size_t len;
     696                 :         13 :                 replydata = (char *) base64_encode(wpabuf_head(reply),
     697                 :            :                                                    wpabuf_len(reply), &len);
     698                 :            :         } else
     699                 :         17 :                 replydata = NULL;
     700                 :            : 
     701                 :            :         /* Parameters of the response:
     702                 :            :          *      action(action_len) -- action we are responding to
     703                 :            :          *      replyname -- a name we need for the reply
     704                 :            :          *      replydata -- NULL or null-terminated string
     705                 :            :          */
     706 [ +  + ][ +  - ]:         30 :         buf = wpabuf_alloc(1000 + (replydata ? os_strlen(replydata) : 0U) +
     707                 :         30 :                            (action_len > 0 ? action_len * 2 : 0));
     708         [ -  + ]:         30 :         if (buf == NULL) {
     709                 :          0 :                 wpa_printf(MSG_INFO, "WPS UPnP: Cannot allocate reply to "
     710                 :            :                            "POST");
     711                 :          0 :                 os_free(replydata);
     712                 :          0 :                 http_request_deinit(req);
     713                 :         30 :                 return;
     714                 :            :         }
     715                 :            : 
     716                 :            :         /*
     717                 :            :          * Assuming we will be successful, put in the output header first.
     718                 :            :          * Note: we do not keep connections alive (and httpread does
     719                 :            :          * not support it)... therefore we must have Connection: close.
     720                 :            :          */
     721         [ +  + ]:         30 :         if (ret == HTTP_OK) {
     722                 :         29 :                 wpabuf_put_str(buf,
     723                 :            :                                "HTTP/1.1 200 OK\r\n"
     724                 :            :                                "Content-Type: text/xml; "
     725                 :            :                                "charset=\"utf-8\"\r\n");
     726                 :            :         } else {
     727                 :          1 :                 wpabuf_printf(buf, "HTTP/1.1 %d Error\r\n", ret);
     728                 :            :         }
     729                 :         30 :         wpabuf_put_str(buf, http_connection_close);
     730                 :            : 
     731                 :         30 :         wpabuf_put_str(buf, "Content-Length: ");
     732                 :            :         /*
     733                 :            :          * We will paste the length in later, leaving some extra whitespace.
     734                 :            :          * HTTP code is supposed to be tolerant of extra whitespace.
     735                 :            :          */
     736                 :         30 :         put_length_here = wpabuf_put(buf, 0);
     737                 :         30 :         wpabuf_put_str(buf, "        \r\n");
     738                 :            : 
     739                 :         30 :         http_put_date(buf);
     740                 :            : 
     741                 :            :         /* terminating empty line */
     742                 :         30 :         wpabuf_put_str(buf, "\r\n");
     743                 :            : 
     744                 :         30 :         body_start = wpabuf_put(buf, 0);
     745                 :            : 
     746         [ +  + ]:         30 :         if (ret == HTTP_OK) {
     747                 :         29 :                 wpabuf_put_str(buf, soap_prefix);
     748                 :         29 :                 wpabuf_put_str(buf, "<u:");
     749                 :         29 :                 wpabuf_put_data(buf, action, action_len);
     750                 :         29 :                 wpabuf_put_str(buf, "Response xmlns:u=\"");
     751                 :         29 :                 wpabuf_put_str(buf, urn_wfawlanconfig);
     752                 :         29 :                 wpabuf_put_str(buf, "\">\n");
     753 [ +  + ][ +  - ]:         29 :                 if (replydata && replyname) {
     754                 :            :                         /* TODO: might possibly need to escape part of reply
     755                 :            :                          * data? ...
     756                 :            :                          * probably not, unlikely to have ampersand(&) or left
     757                 :            :                          * angle bracket (<) in it...
     758                 :            :                          */
     759                 :         13 :                         wpabuf_printf(buf, "<%s>", replyname);
     760                 :         13 :                         wpabuf_put_str(buf, replydata);
     761                 :         13 :                         wpabuf_printf(buf, "</%s>\n", replyname);
     762                 :            :                 }
     763                 :         29 :                 wpabuf_put_str(buf, "</u:");
     764                 :         29 :                 wpabuf_put_data(buf, action, action_len);
     765                 :         29 :                 wpabuf_put_str(buf, "Response>\n");
     766                 :         29 :                 wpabuf_put_str(buf, soap_postfix);
     767                 :            :         } else {
     768                 :            :                 /* Error case */
     769                 :          1 :                 wpabuf_put_str(buf, soap_prefix);
     770                 :          1 :                 wpabuf_put_str(buf, soap_error_prefix);
     771                 :          1 :                 wpabuf_printf(buf, "<errorCode>%d</errorCode>\n", ret);
     772                 :          1 :                 wpabuf_put_str(buf, soap_error_postfix);
     773                 :          1 :                 wpabuf_put_str(buf, soap_postfix);
     774                 :            :         }
     775                 :         30 :         os_free(replydata);
     776                 :            : 
     777                 :            :         /* Now patch in the content length at the end */
     778 [ +  - ][ +  - ]:         30 :         if (body_start && put_length_here) {
     779                 :         30 :                 int body_length = (char *) wpabuf_put(buf, 0) - body_start;
     780                 :            :                 char len_buf[10];
     781                 :         30 :                 os_snprintf(len_buf, sizeof(len_buf), "%d", body_length);
     782                 :         30 :                 os_memcpy(put_length_here, len_buf, os_strlen(len_buf));
     783                 :            :         }
     784                 :            : 
     785                 :         30 :         http_request_send_and_deinit(req, buf);
     786                 :            : }
     787                 :            : 
     788                 :            : 
     789                 :         30 : static const char * web_get_action(struct http_request *req,
     790                 :            :                                    size_t *action_len)
     791                 :            : {
     792                 :            :         const char *match;
     793                 :            :         int match_len;
     794                 :            :         char *b;
     795                 :            :         char *action;
     796                 :            : 
     797                 :         30 :         *action_len = 0;
     798                 :            :         /* The SOAPAction line of the header tells us what we want to do */
     799                 :         30 :         b = http_request_get_hdr_line(req, "SOAPAction:");
     800         [ -  + ]:         30 :         if (b == NULL)
     801                 :          0 :                 return NULL;
     802         [ +  - ]:         30 :         if (*b == '"')
     803                 :         30 :                 b++;
     804                 :            :         else
     805                 :          0 :                 return NULL;
     806                 :         30 :         match = urn_wfawlanconfig;
     807                 :         30 :         match_len = os_strlen(urn_wfawlanconfig) - 1;
     808         [ -  + ]:         30 :         if (os_strncasecmp(b, match, match_len))
     809                 :          0 :                 return NULL;
     810                 :         30 :         b += match_len;
     811                 :            :         /* skip over version */
     812 [ +  - ][ +  + ]:         60 :         while (isgraph(*b) && *b != '#')
     813                 :         30 :                 b++;
     814         [ -  + ]:         30 :         if (*b != '#')
     815                 :          0 :                 return NULL;
     816                 :         30 :         b++;
     817                 :            :         /* Following the sharp(#) should be the action and a double quote */
     818                 :         30 :         action = b;
     819 [ +  - ][ +  + ]:        468 :         while (isgraph(*b) && *b != '"')
     820                 :        438 :                 b++;
     821         [ -  + ]:         30 :         if (*b != '"')
     822                 :          0 :                 return NULL;
     823                 :         30 :         *action_len = b - action;
     824                 :         30 :         return action;
     825                 :            : }
     826                 :            : 
     827                 :            : 
     828                 :            : /* Given that we have received a header w/ POST, act upon it
     829                 :            :  *
     830                 :            :  * Format of POST (case-insensitive):
     831                 :            :  *
     832                 :            :  * First line must be:
     833                 :            :  *      POST /<file> HTTP/1.1
     834                 :            :  * Since we don't do anything fancy we just ignore other lines.
     835                 :            :  *
     836                 :            :  * Our response (if no error) which includes only required lines is:
     837                 :            :  * HTTP/1.1 200 OK
     838                 :            :  * Connection: close
     839                 :            :  * Content-Type: text/xml
     840                 :            :  * Date: <rfc1123-date>
     841                 :            :  *
     842                 :            :  * Header lines must end with \r\n
     843                 :            :  * Per RFC 2616, content-length: is not required but connection:close
     844                 :            :  * would appear to be required (given that we will be closing it!).
     845                 :            :  */
     846                 :         30 : static void web_connection_parse_post(struct upnp_wps_device_sm *sm,
     847                 :            :                                       struct sockaddr_in *cli,
     848                 :            :                                       struct http_request *req,
     849                 :            :                                       const char *filename)
     850                 :            : {
     851                 :            :         enum http_reply_code ret;
     852                 :         30 :         char *data = http_request_get_data(req); /* body of http msg */
     853                 :         30 :         const char *action = NULL;
     854                 :         30 :         size_t action_len = 0;
     855                 :         30 :         const char *replyname = NULL; /* argument name for the reply */
     856                 :         30 :         struct wpabuf *reply = NULL; /* data for the reply */
     857                 :            : 
     858         [ -  + ]:         30 :         if (os_strcasecmp(filename, UPNP_WPS_DEVICE_CONTROL_FILE)) {
     859                 :          0 :                 wpa_printf(MSG_INFO, "WPS UPnP: Invalid POST filename %s",
     860                 :            :                            filename);
     861                 :          0 :                 ret = HTTP_NOT_FOUND;
     862                 :          0 :                 goto bad;
     863                 :            :         }
     864                 :            : 
     865                 :         30 :         ret = UPNP_INVALID_ACTION;
     866                 :         30 :         action = web_get_action(req, &action_len);
     867         [ -  + ]:         30 :         if (action == NULL)
     868                 :          0 :                 goto bad;
     869                 :            : 
     870         [ +  + ]:         30 :         if (!os_strncasecmp("GetDeviceInfo", action, action_len))
     871                 :          6 :                 ret = web_process_get_device_info(sm, &reply, &replyname);
     872         [ +  + ]:         24 :         else if (!os_strncasecmp("PutMessage", action, action_len))
     873                 :          8 :                 ret = web_process_put_message(sm, data, &reply, &replyname);
     874         [ +  + ]:         16 :         else if (!os_strncasecmp("PutWLANResponse", action, action_len))
     875                 :          8 :                 ret = web_process_put_wlan_response(sm, data, &reply,
     876                 :            :                                                     &replyname);
     877         [ +  - ]:          8 :         else if (!os_strncasecmp("SetSelectedRegistrar", action, action_len))
     878                 :          8 :                 ret = web_process_set_selected_registrar(sm, cli, data, &reply,
     879                 :            :                                                          &replyname);
     880                 :            :         else
     881                 :          0 :                 wpa_printf(MSG_INFO, "WPS UPnP: Unknown POST type");
     882                 :            : 
     883                 :            : bad:
     884         [ +  + ]:         30 :         if (ret != HTTP_OK)
     885                 :          1 :                 wpa_printf(MSG_INFO, "WPS UPnP: POST failure ret=%d", ret);
     886                 :         30 :         web_connection_send_reply(req, ret, action, action_len, reply,
     887                 :            :                                   replyname);
     888                 :         30 :         wpabuf_free(reply);
     889                 :         30 : }
     890                 :            : 
     891                 :            : 
     892                 :            : /* Given that we have received a header w/ SUBSCRIBE, act upon it
     893                 :            :  *
     894                 :            :  * Format of SUBSCRIBE (case-insensitive):
     895                 :            :  *
     896                 :            :  * First line must be:
     897                 :            :  *      SUBSCRIBE /wps_event HTTP/1.1
     898                 :            :  *
     899                 :            :  * Our response (if no error) which includes only required lines is:
     900                 :            :  * HTTP/1.1 200 OK
     901                 :            :  * Server: xx, UPnP/1.0, xx
     902                 :            :  * SID: uuid:xxxxxxxxx
     903                 :            :  * Timeout: Second-<n>
     904                 :            :  * Content-Length: 0
     905                 :            :  * Date: xxxx
     906                 :            :  *
     907                 :            :  * Header lines must end with \r\n
     908                 :            :  * Per RFC 2616, content-length: is not required but connection:close
     909                 :            :  * would appear to be required (given that we will be closing it!).
     910                 :            :  */
     911                 :          4 : static void web_connection_parse_subscribe(struct upnp_wps_device_sm *sm,
     912                 :            :                                            struct http_request *req,
     913                 :            :                                            const char *filename)
     914                 :            : {
     915                 :            :         struct wpabuf *buf;
     916                 :            :         char *b;
     917                 :          4 :         char *hdr = http_request_get_hdr(req);
     918                 :            :         char *h;
     919                 :            :         char *match;
     920                 :            :         int match_len;
     921                 :            :         char *end;
     922                 :            :         int len;
     923                 :          4 :         int got_nt = 0;
     924                 :            :         u8 uuid[UUID_LEN];
     925                 :          4 :         int got_uuid = 0;
     926                 :          4 :         char *callback_urls = NULL;
     927                 :          4 :         struct subscription *s = NULL;
     928                 :          4 :         enum http_reply_code ret = HTTP_INTERNAL_SERVER_ERROR;
     929                 :            : 
     930                 :          4 :         buf = wpabuf_alloc(1000);
     931         [ -  + ]:          4 :         if (buf == NULL) {
     932                 :          0 :                 http_request_deinit(req);
     933                 :          0 :                 return;
     934                 :            :         }
     935                 :            : 
     936                 :          4 :         wpa_hexdump_ascii(MSG_DEBUG, "WPS UPnP: HTTP SUBSCRIBE",
     937                 :            :                           (u8 *) hdr, os_strlen(hdr));
     938                 :            : 
     939                 :            :         /* Parse/validate headers */
     940                 :          4 :         h = hdr;
     941                 :            :         /* First line: SUBSCRIBE /wps_event HTTP/1.1
     942                 :            :          * has already been parsed.
     943                 :            :          */
     944         [ -  + ]:          4 :         if (os_strcasecmp(filename, UPNP_WPS_DEVICE_EVENT_FILE) != 0) {
     945                 :          0 :                 ret = HTTP_PRECONDITION_FAILED;
     946                 :          0 :                 goto error;
     947                 :            :         }
     948                 :          4 :         wpa_printf(MSG_DEBUG, "WPS UPnP: HTTP SUBSCRIBE for event");
     949                 :          4 :         end = os_strchr(h, '\n');
     950                 :            : 
     951         [ +  - ]:         24 :         for (; end != NULL; h = end + 1) {
     952                 :            :                 /* Option line by option line */
     953                 :         24 :                 h = end + 1;
     954                 :         24 :                 end = os_strchr(h, '\n');
     955         [ +  + ]:         24 :                 if (end == NULL)
     956                 :          4 :                         break; /* no unterminated lines allowed */
     957                 :            : 
     958                 :            :                 /* NT assures that it is our type of subscription;
     959                 :            :                  * not used for a renewal.
     960                 :            :                  **/
     961                 :         20 :                 match = "NT:";
     962                 :         20 :                 match_len = os_strlen(match);
     963         [ +  + ]:         20 :                 if (os_strncasecmp(h, match, match_len) == 0) {
     964                 :          4 :                         h += match_len;
     965 [ +  + ][ -  + ]:          8 :                         while (*h == ' ' || *h == '\t')
     966                 :          4 :                                 h++;
     967                 :          4 :                         match = "upnp:event";
     968                 :          4 :                         match_len = os_strlen(match);
     969         [ -  + ]:          4 :                         if (os_strncasecmp(h, match, match_len) != 0) {
     970                 :          0 :                                 ret = HTTP_BAD_REQUEST;
     971                 :          0 :                                 goto error;
     972                 :            :                         }
     973                 :          4 :                         got_nt = 1;
     974                 :          4 :                         continue;
     975                 :            :                 }
     976                 :            :                 /* HOST should refer to us */
     977                 :            : #if 0
     978                 :            :                 match = "HOST:";
     979                 :            :                 match_len = os_strlen(match);
     980                 :            :                 if (os_strncasecmp(h, match, match_len) == 0) {
     981                 :            :                         h += match_len;
     982                 :            :                         while (*h == ' ' || *h == '\t')
     983                 :            :                                 h++;
     984                 :            :                         .....
     985                 :            :                 }
     986                 :            : #endif
     987                 :            :                 /* CALLBACK gives one or more URLs for NOTIFYs
     988                 :            :                  * to be sent as a result of the subscription.
     989                 :            :                  * Each URL is enclosed in angle brackets.
     990                 :            :                  */
     991                 :         16 :                 match = "CALLBACK:";
     992                 :         16 :                 match_len = os_strlen(match);
     993         [ +  + ]:         16 :                 if (os_strncasecmp(h, match, match_len) == 0) {
     994                 :          4 :                         h += match_len;
     995 [ +  + ][ -  + ]:          8 :                         while (*h == ' ' || *h == '\t')
     996                 :          4 :                                 h++;
     997                 :          4 :                         len = end - h;
     998                 :          4 :                         os_free(callback_urls);
     999                 :          4 :                         callback_urls = dup_binstr(h, len);
    1000         [ -  + ]:          4 :                         if (callback_urls == NULL) {
    1001                 :          0 :                                 ret = HTTP_INTERNAL_SERVER_ERROR;
    1002                 :          0 :                                 goto error;
    1003                 :            :                         }
    1004                 :          4 :                         continue;
    1005                 :            :                 }
    1006                 :            :                 /* SID is only for renewal */
    1007                 :         12 :                 match = "SID:";
    1008                 :         12 :                 match_len = os_strlen(match);
    1009         [ -  + ]:         12 :                 if (os_strncasecmp(h, match, match_len) == 0) {
    1010                 :          0 :                         h += match_len;
    1011 [ #  # ][ #  # ]:          0 :                         while (*h == ' ' || *h == '\t')
    1012                 :          0 :                                 h++;
    1013                 :          0 :                         match = "uuid:";
    1014                 :          0 :                         match_len = os_strlen(match);
    1015         [ #  # ]:          0 :                         if (os_strncasecmp(h, match, match_len) != 0) {
    1016                 :          0 :                                 ret = HTTP_BAD_REQUEST;
    1017                 :          0 :                                 goto error;
    1018                 :            :                         }
    1019                 :          0 :                         h += match_len;
    1020 [ #  # ][ #  # ]:          0 :                         while (*h == ' ' || *h == '\t')
    1021                 :          0 :                                 h++;
    1022         [ #  # ]:          0 :                         if (uuid_str2bin(h, uuid)) {
    1023                 :          0 :                                 ret = HTTP_BAD_REQUEST;
    1024                 :          0 :                                 goto error;
    1025                 :            :                         }
    1026                 :          0 :                         got_uuid = 1;
    1027                 :          0 :                         continue;
    1028                 :            :                 }
    1029                 :            :                 /* TIMEOUT is requested timeout, but apparently we can
    1030                 :            :                  * just ignore this.
    1031                 :            :                  */
    1032                 :            :         }
    1033                 :            : 
    1034         [ -  + ]:          4 :         if (got_uuid) {
    1035                 :            :                 /* renewal */
    1036                 :          0 :                 wpa_printf(MSG_DEBUG, "WPS UPnP: Subscription renewal");
    1037         [ #  # ]:          0 :                 if (callback_urls) {
    1038                 :          0 :                         ret = HTTP_BAD_REQUEST;
    1039                 :          0 :                         goto error;
    1040                 :            :                 }
    1041                 :          0 :                 s = subscription_renew(sm, uuid);
    1042         [ #  # ]:          0 :                 if (s == NULL) {
    1043                 :            :                         char str[80];
    1044                 :          0 :                         uuid_bin2str(uuid, str, sizeof(str));
    1045                 :          0 :                         wpa_printf(MSG_DEBUG, "WPS UPnP: Could not find "
    1046                 :            :                                    "SID %s", str);
    1047                 :          0 :                         ret = HTTP_PRECONDITION_FAILED;
    1048                 :          0 :                         goto error;
    1049                 :            :                 }
    1050         [ +  - ]:          4 :         } else if (callback_urls) {
    1051                 :          4 :                 wpa_printf(MSG_DEBUG, "WPS UPnP: New subscription");
    1052         [ -  + ]:          4 :                 if (!got_nt) {
    1053                 :          0 :                         ret = HTTP_PRECONDITION_FAILED;
    1054                 :          0 :                         goto error;
    1055                 :            :                 }
    1056                 :          4 :                 s = subscription_start(sm, callback_urls);
    1057         [ -  + ]:          4 :                 if (s == NULL) {
    1058                 :          0 :                         ret = HTTP_INTERNAL_SERVER_ERROR;
    1059                 :          0 :                         goto error;
    1060                 :            :                 }
    1061                 :            :         } else {
    1062                 :          0 :                 ret = HTTP_PRECONDITION_FAILED;
    1063                 :          0 :                 goto error;
    1064                 :            :         }
    1065                 :            : 
    1066                 :            :         /* success */
    1067                 :          4 :         http_put_reply_code(buf, HTTP_OK);
    1068                 :          4 :         wpabuf_put_str(buf, http_server_hdr);
    1069                 :          4 :         wpabuf_put_str(buf, http_connection_close);
    1070                 :          4 :         wpabuf_put_str(buf, "Content-Length: 0\r\n");
    1071                 :          4 :         wpabuf_put_str(buf, "SID: uuid:");
    1072                 :            :         /* subscription id */
    1073                 :          4 :         b = wpabuf_put(buf, 0);
    1074                 :          4 :         uuid_bin2str(s->uuid, b, 80);
    1075                 :          4 :         wpa_printf(MSG_DEBUG, "WPS UPnP: Assigned SID %s", b);
    1076                 :          4 :         wpabuf_put(buf, os_strlen(b));
    1077                 :          4 :         wpabuf_put_str(buf, "\r\n");
    1078                 :          4 :         wpabuf_printf(buf, "Timeout: Second-%d\r\n", UPNP_SUBSCRIBE_SEC);
    1079                 :          4 :         http_put_date(buf);
    1080                 :            :         /* And empty line to terminate header: */
    1081                 :          4 :         wpabuf_put_str(buf, "\r\n");
    1082                 :            : 
    1083                 :          4 :         os_free(callback_urls);
    1084                 :          4 :         http_request_send_and_deinit(req, buf);
    1085                 :          4 :         return;
    1086                 :            : 
    1087                 :            : error:
    1088                 :            :         /* Per UPnP spec:
    1089                 :            :         * Errors
    1090                 :            :         * Incompatible headers
    1091                 :            :         *   400 Bad Request. If SID header and one of NT or CALLBACK headers
    1092                 :            :         *     are present, the publisher must respond with HTTP error
    1093                 :            :         *     400 Bad Request.
    1094                 :            :         * Missing or invalid CALLBACK
    1095                 :            :         *   412 Precondition Failed. If CALLBACK header is missing or does not
    1096                 :            :         *     contain a valid HTTP URL, the publisher must respond with HTTP
    1097                 :            :         *     error 412 Precondition Failed.
    1098                 :            :         * Invalid NT
    1099                 :            :         *   412 Precondition Failed. If NT header does not equal upnp:event,
    1100                 :            :         *     the publisher must respond with HTTP error 412 Precondition
    1101                 :            :         *     Failed.
    1102                 :            :         * [For resubscription, use 412 if unknown uuid].
    1103                 :            :         * Unable to accept subscription
    1104                 :            :         *   5xx. If a publisher is not able to accept a subscription (such as
    1105                 :            :         *     due to insufficient resources), it must respond with a
    1106                 :            :         *     HTTP 500-series error code.
    1107                 :            :         *   599 Too many subscriptions (not a standard HTTP error)
    1108                 :            :         */
    1109                 :          0 :         wpa_printf(MSG_DEBUG, "WPS UPnP: SUBSCRIBE failed - return %d", ret);
    1110                 :          0 :         http_put_empty(buf, ret);
    1111                 :          0 :         http_request_send_and_deinit(req, buf);
    1112                 :          4 :         os_free(callback_urls);
    1113                 :            : }
    1114                 :            : 
    1115                 :            : 
    1116                 :            : /* Given that we have received a header w/ UNSUBSCRIBE, act upon it
    1117                 :            :  *
    1118                 :            :  * Format of UNSUBSCRIBE (case-insensitive):
    1119                 :            :  *
    1120                 :            :  * First line must be:
    1121                 :            :  *      UNSUBSCRIBE /wps_event HTTP/1.1
    1122                 :            :  *
    1123                 :            :  * Our response (if no error) which includes only required lines is:
    1124                 :            :  * HTTP/1.1 200 OK
    1125                 :            :  * Content-Length: 0
    1126                 :            :  *
    1127                 :            :  * Header lines must end with \r\n
    1128                 :            :  * Per RFC 2616, content-length: is not required but connection:close
    1129                 :            :  * would appear to be required (given that we will be closing it!).
    1130                 :            :  */
    1131                 :          1 : static void web_connection_parse_unsubscribe(struct upnp_wps_device_sm *sm,
    1132                 :            :                                              struct http_request *req,
    1133                 :            :                                              const char *filename)
    1134                 :            : {
    1135                 :            :         struct wpabuf *buf;
    1136                 :          1 :         char *hdr = http_request_get_hdr(req);
    1137                 :            :         char *h;
    1138                 :            :         char *match;
    1139                 :            :         int match_len;
    1140                 :            :         char *end;
    1141                 :            :         u8 uuid[UUID_LEN];
    1142                 :          1 :         int got_uuid = 0;
    1143                 :          1 :         struct subscription *s = NULL;
    1144                 :          1 :         enum http_reply_code ret = HTTP_INTERNAL_SERVER_ERROR;
    1145                 :            : 
    1146                 :            :         /* Parse/validate headers */
    1147                 :          1 :         h = hdr;
    1148                 :            :         /* First line: UNSUBSCRIBE /wps_event HTTP/1.1
    1149                 :            :          * has already been parsed.
    1150                 :            :          */
    1151         [ -  + ]:          1 :         if (os_strcasecmp(filename, UPNP_WPS_DEVICE_EVENT_FILE) != 0) {
    1152                 :          0 :                 ret = HTTP_PRECONDITION_FAILED;
    1153                 :          0 :                 goto send_msg;
    1154                 :            :         }
    1155                 :          1 :         wpa_printf(MSG_DEBUG, "WPS UPnP: HTTP UNSUBSCRIBE for event");
    1156                 :          1 :         end = os_strchr(h, '\n');
    1157                 :            : 
    1158         [ +  - ]:          4 :         for (; end != NULL; h = end + 1) {
    1159                 :            :                 /* Option line by option line */
    1160                 :          4 :                 h = end + 1;
    1161                 :          4 :                 end = os_strchr(h, '\n');
    1162         [ +  + ]:          4 :                 if (end == NULL)
    1163                 :          1 :                         break; /* no unterminated lines allowed */
    1164                 :            : 
    1165                 :            :                 /* HOST should refer to us */
    1166                 :            : #if 0
    1167                 :            :                 match = "HOST:";
    1168                 :            :                 match_len = os_strlen(match);
    1169                 :            :                 if (os_strncasecmp(h, match, match_len) == 0) {
    1170                 :            :                         h += match_len;
    1171                 :            :                         while (*h == ' ' || *h == '\t')
    1172                 :            :                                 h++;
    1173                 :            :                         .....
    1174                 :            :                 }
    1175                 :            : #endif
    1176                 :            :                 /* SID is only for renewal */
    1177                 :          3 :                 match = "SID:";
    1178                 :          3 :                 match_len = os_strlen(match);
    1179         [ +  + ]:          3 :                 if (os_strncasecmp(h, match, match_len) == 0) {
    1180                 :          1 :                         h += match_len;
    1181 [ +  + ][ -  + ]:          2 :                         while (*h == ' ' || *h == '\t')
    1182                 :          1 :                                 h++;
    1183                 :          1 :                         match = "uuid:";
    1184                 :          1 :                         match_len = os_strlen(match);
    1185         [ -  + ]:          1 :                         if (os_strncasecmp(h, match, match_len) != 0) {
    1186                 :          0 :                                 ret = HTTP_BAD_REQUEST;
    1187                 :          0 :                                 goto send_msg;
    1188                 :            :                         }
    1189                 :          1 :                         h += match_len;
    1190 [ -  + ][ -  + ]:          1 :                         while (*h == ' ' || *h == '\t')
    1191                 :          0 :                                 h++;
    1192         [ -  + ]:          1 :                         if (uuid_str2bin(h, uuid)) {
    1193                 :          0 :                                 ret = HTTP_BAD_REQUEST;
    1194                 :          0 :                                 goto send_msg;
    1195                 :            :                         }
    1196                 :          1 :                         got_uuid = 1;
    1197                 :          1 :                         continue;
    1198                 :            :                 }
    1199                 :            :         }
    1200                 :            : 
    1201         [ +  - ]:          1 :         if (got_uuid) {
    1202                 :          1 :                 s = subscription_find(sm, uuid);
    1203         [ +  - ]:          1 :                 if (s) {
    1204                 :            :                         struct subscr_addr *sa;
    1205         [ +  - ]:          1 :                         sa = dl_list_first(&s->addr_list, struct subscr_addr,
    1206                 :            :                                            list);
    1207         [ +  - ]:          2 :                         wpa_printf(MSG_DEBUG, "WPS UPnP: Unsubscribing %p %s",
    1208         [ +  - ]:          1 :                                    s, (sa && sa->domain_and_port) ?
    1209                 :            :                                    sa->domain_and_port : "-null-");
    1210                 :          1 :                         dl_list_del(&s->list);
    1211                 :          1 :                         subscription_destroy(s);
    1212                 :            :                 }
    1213                 :            :         } else {
    1214                 :          0 :                 wpa_printf(MSG_INFO, "WPS UPnP: Unsubscribe fails (not "
    1215                 :            :                            "found)");
    1216                 :          0 :                 ret = HTTP_PRECONDITION_FAILED;
    1217                 :          0 :                 goto send_msg;
    1218                 :            :         }
    1219                 :            : 
    1220                 :          1 :         ret = HTTP_OK;
    1221                 :            : 
    1222                 :            : send_msg:
    1223                 :          1 :         buf = wpabuf_alloc(200);
    1224         [ -  + ]:          1 :         if (buf == NULL) {
    1225                 :          0 :                 http_request_deinit(req);
    1226                 :          1 :                 return;
    1227                 :            :         }
    1228                 :          1 :         http_put_empty(buf, ret);
    1229                 :          1 :         http_request_send_and_deinit(req, buf);
    1230                 :            : }
    1231                 :            : 
    1232                 :            : 
    1233                 :            : /* Send error in response to unknown requests */
    1234                 :          0 : static void web_connection_unimplemented(struct http_request *req)
    1235                 :            : {
    1236                 :            :         struct wpabuf *buf;
    1237                 :          0 :         buf = wpabuf_alloc(200);
    1238         [ #  # ]:          0 :         if (buf == NULL) {
    1239                 :          0 :                 http_request_deinit(req);
    1240                 :          0 :                 return;
    1241                 :            :         }
    1242                 :          0 :         http_put_empty(buf, HTTP_UNIMPLEMENTED);
    1243                 :          0 :         http_request_send_and_deinit(req, buf);
    1244                 :            : }
    1245                 :            : 
    1246                 :            : 
    1247                 :            : 
    1248                 :            : /* Called when we have gotten an apparently valid http request.
    1249                 :            :  */
    1250                 :         39 : static void web_connection_check_data(void *ctx, struct http_request *req)
    1251                 :            : {
    1252                 :         39 :         struct upnp_wps_device_sm *sm = ctx;
    1253                 :         39 :         enum httpread_hdr_type htype = http_request_get_type(req);
    1254                 :         39 :         char *filename = http_request_get_uri(req);
    1255                 :         39 :         struct sockaddr_in *cli = http_request_get_cli_addr(req);
    1256                 :            : 
    1257         [ -  + ]:         39 :         if (!filename) {
    1258                 :          0 :                 wpa_printf(MSG_INFO, "WPS UPnP: Could not get HTTP URI");
    1259                 :          0 :                 http_request_deinit(req);
    1260                 :         39 :                 return;
    1261                 :            :         }
    1262                 :            :         /* Trim leading slashes from filename */
    1263         [ +  + ]:         78 :         while (*filename == '/')
    1264                 :         39 :                 filename++;
    1265                 :            : 
    1266                 :         39 :         wpa_printf(MSG_DEBUG, "WPS UPnP: Got HTTP request type %d from %s:%d",
    1267                 :         39 :                    htype, inet_ntoa(cli->sin_addr), htons(cli->sin_port));
    1268                 :            : 
    1269   [ +  +  +  +  :         39 :         switch (htype) {
                      - ]
    1270                 :            :         case HTTPREAD_HDR_TYPE_GET:
    1271                 :          4 :                 web_connection_parse_get(sm, req, filename);
    1272                 :          4 :                 break;
    1273                 :            :         case HTTPREAD_HDR_TYPE_POST:
    1274                 :         30 :                 web_connection_parse_post(sm, cli, req, filename);
    1275                 :         30 :                 break;
    1276                 :            :         case HTTPREAD_HDR_TYPE_SUBSCRIBE:
    1277                 :          4 :                 web_connection_parse_subscribe(sm, req, filename);
    1278                 :          4 :                 break;
    1279                 :            :         case HTTPREAD_HDR_TYPE_UNSUBSCRIBE:
    1280                 :          1 :                 web_connection_parse_unsubscribe(sm, req, filename);
    1281                 :          1 :                 break;
    1282                 :            : 
    1283                 :            :                 /* We are not required to support M-POST; just plain
    1284                 :            :                  * POST is supposed to work, so we only support that.
    1285                 :            :                  * If for some reason we need to support M-POST, it is
    1286                 :            :                  * mostly the same as POST, with small differences.
    1287                 :            :                  */
    1288                 :            :         default:
    1289                 :            :                 /* Send 501 for anything else */
    1290                 :          0 :                 web_connection_unimplemented(req);
    1291                 :          0 :                 break;
    1292                 :            :         }
    1293                 :            : }
    1294                 :            : 
    1295                 :            : 
    1296                 :            : /*
    1297                 :            :  * Listening for web connections
    1298                 :            :  * We have a single TCP listening port, and hand off connections as we get
    1299                 :            :  * them.
    1300                 :            :  */
    1301                 :            : 
    1302                 :          4 : void web_listener_stop(struct upnp_wps_device_sm *sm)
    1303                 :            : {
    1304                 :          4 :         http_server_deinit(sm->web_srv);
    1305                 :          4 :         sm->web_srv = NULL;
    1306                 :          4 : }
    1307                 :            : 
    1308                 :            : 
    1309                 :          4 : int web_listener_start(struct upnp_wps_device_sm *sm)
    1310                 :            : {
    1311                 :            :         struct in_addr addr;
    1312                 :          4 :         addr.s_addr = sm->ip_addr;
    1313                 :          4 :         sm->web_srv = http_server_init(&addr, -1, web_connection_check_data,
    1314                 :            :                                        sm);
    1315         [ -  + ]:          4 :         if (sm->web_srv == NULL) {
    1316                 :          0 :                 web_listener_stop(sm);
    1317                 :          0 :                 return -1;
    1318                 :            :         }
    1319                 :          4 :         sm->web_port = http_server_get_port(sm->web_srv);
    1320                 :            : 
    1321                 :          4 :         return 0;
    1322                 :            : }

Generated by: LCOV version 1.9