Changeset 11510


Ignore:
Timestamp:
Dec 10, 2010, 4:07:30 AM (11 years ago)
Author:
livings124
Message:

update to miniupnpc-1.4.20101209

Location:
trunk/third-party/miniupnp
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • trunk/third-party/miniupnp/Changelog.txt

    r10739 r11510  
    1 $Id: Changelog.txt,v 1.117 2010/06/09 10:59:08 nanard Exp $
     1$Id: Changelog.txt,v 1.122 2010/12/09 16:11:31 nanard Exp $
    22miniUPnP client Changelog.
     3
     42010/12/09:
     5  new code for miniwget that handle Chunked transfer encoding
     6  using getHTTPResponse() in SOAP call code
     7
     82010/11/25:
     9  changes to minissdpc.c to compile under Win32.
     10  see http://miniupnp.tuxfamily.org/forum/viewtopic.php?t=729
     11
     122010/09/17:
     13  Various improvement to Makefile from Michał Górny
     14
     152010/08/05:
     16  Adding the script "external-ip.sh" from Reuben Hawkins
    317
    4182010/06/09:
  • trunk/third-party/miniupnp/minissdpc.c

    r10285 r11510  
    1 /* $Id: minissdpc.c,v 1.13 2009/12/04 16:57:29 nanard Exp $ */
     1/* $Id: minissdpc.c,v 1.14 2010/11/25 09:57:25 nanard Exp $ */
    22/* Project : miniupnp
    33 * Author : Thomas BERNARD
     
    1616#include <ws2tcpip.h>
    1717#include <io.h>
     18#include <winsock.h>
     19#include <stdint.h>
    1820#endif
    1921#if defined(__amigaos__) || defined(__amigaos4__)
  • trunk/third-party/miniupnp/miniupnpc.c

    r10913 r11510  
    1 /* $Id: miniupnpc.c,v 1.81 2010/04/17 22:07:59 nanard Exp $ */
     1/* $Id: miniupnpc.c,v 1.83 2010/12/09 16:11:32 nanard Exp $ */
    22/* Project : miniupnp
    33 * Author : Thomas BERNARD
     
    100100}
    101101
     102#if 0
    102103/* getcontentlenfromline() : parse the Content-Length HTTP header line.
    103104 * Content-length: nnn */
     
    168169        }
    169170}
     171#endif
    170172
    171173/* simpleUPnPcommand2 :
     
    184186        char soapbody[2048];
    185187        char * buf;
    186         int buffree;
     188        /*int buffree;*/
    187189    int n;
    188         int contentlen, headerlen;      /* for the response */
     190        /*int contentlen, headerlen;*/  /* for the response */
    189191
    190192        snprintf(soapact, sizeof(soapact), "%s#%s", service, action);
     
    273275        }
    274276
     277#if 0
    275278        contentlen = -1;
    276279        headerlen = -1;
     
    292295                        break;
    293296        }
    294        
     297#endif
     298        buf = getHTTPResponse(s, &n);
     299        if(n > 0 && buf)
     300        {
     301                if(*bufsize > n)
     302                {
     303                        memcpy(buffer, buf, n);
     304                        *bufsize = n;
     305                }
     306                else
     307                {
     308                        memcpy(buffer, buf, *bufsize);
     309                }
     310                free(buf);
     311                buf = 0;
     312        }
    295313        closesocket(s);
    296314        return 0;
     
    307325{
    308326        int result;
    309         int origbufsize = *bufsize;
    310 
     327        /*int origbufsize = *bufsize;*/
     328
     329        result = simpleUPnPcommand2(s, url, service, action, args, buffer, bufsize, "1.1");
     330/*
    311331        result = simpleUPnPcommand2(s, url, service, action, args, buffer, bufsize, "1.0");
    312332        if (result < 0 || *bufsize == 0)
     
    318338                result = simpleUPnPcommand2(s, url, service, action, args, buffer, bufsize, "1.1");
    319339        }
     340*/
    320341        return result;
    321342}
  • trunk/third-party/miniupnp/miniwget.c

    r10472 r11510  
    1 /* $Id: miniwget.c,v 1.37 2010/04/12 20:39:42 nanard Exp $ */
     1/* $Id: miniwget.c,v 1.38 2010/12/09 15:54:25 nanard Exp $ */
    22/* Project : miniupnp
    33 * Author : Thomas Bernard
     
    99#include <stdlib.h>
    1010#include <string.h>
     11#include <ctype.h>
    1112#include "miniupnpc.h"
    1213#ifdef WIN32
     
    4243#include "connecthostport.h"
    4344
     45/*
     46 * Read a HTTP response from a socket.
     47 * Process Content-Length and Transfer-encoding headers.
     48 */
     49void *
     50getHTTPResponse(int s, int * size)
     51{
     52        char buf[2048];
     53        int n;
     54        int headers = 1;
     55        int chunked = 0;
     56        int content_length = -1;
     57        unsigned int chunksize = 0;
     58        /* buffers : */
     59        char * header_buf;
     60        int header_buf_len = 2048;
     61        int header_buf_used = 0;
     62        char * content_buf;
     63        int content_buf_len = 2048;
     64        int content_buf_used = 0;
     65
     66        header_buf = malloc(header_buf_len);
     67        content_buf = malloc(content_buf_len);
     68
     69        while((n = ReceiveData(s, buf, 2048, 5000)) > 0)
     70        {
     71                if(headers)
     72                {
     73                        int i;
     74                        int linestart=0;
     75                        int colon=0;
     76                        int valuestart=0;
     77                        if(header_buf_used + n > header_buf_len) {
     78                                header_buf = realloc(header_buf, header_buf_used + n);
     79                                header_buf_len = header_buf_used + n;
     80                        }
     81                        memcpy(header_buf + header_buf_used, buf, n);
     82                        header_buf_used += n;
     83                        for(i = 0; i < (header_buf_used-3); i++) {
     84                                if(colon <= linestart && header_buf[i]==':')
     85                                {
     86                                        colon = i;
     87                                        while(i < (n-3)
     88                                              && (header_buf[i+1] == ' ' || header_buf[i+1] == '\t'))
     89                                                i++;
     90                                        valuestart = i + 1;
     91                                }
     92                                /* detecting end of line */
     93                                else if(header_buf[i]=='\r' && header_buf[i+1]=='\n')
     94                                {
     95                                        if(colon > linestart && valuestart > colon)
     96                                        {
     97#ifdef DEBUG
     98                                                printf("header='%.*s', value='%.*s'\n",
     99                                                       colon-linestart, header_buf+linestart,
     100                                                       i-valuestart, header_buf+valuestart);
     101#endif
     102                                                if(0==strncasecmp(header_buf+linestart, "content-length", colon-linestart))
     103                                                {
     104                                                        content_length = atoi(header_buf+valuestart);
     105#ifdef DEBUG
     106                                                        printf("Content-Length: %d\n", content_length);
     107#endif
     108                                                }
     109                                                else if(0==strncasecmp(header_buf+linestart, "transfer-encoding", colon-linestart)
     110                                                   && 0==strncasecmp(buf+valuestart, "chunked", 7))
     111                                                {
     112#ifdef DEBUG
     113                                                        printf("chunked transfer-encoding!\n");
     114#endif
     115                                                        chunked = 1;
     116                                                }
     117                                        }
     118                                        linestart = i+2;
     119                                        colon = linestart;
     120                                        valuestart = 0;
     121                                }
     122                                /* searching for the end of the HTTP headers */
     123                                if(header_buf[i]=='\r' && header_buf[i+1]=='\n'
     124                                   && header_buf[i+2]=='\r' && header_buf[i+3]=='\n')
     125                                {
     126                                        headers = 0;    /* end */
     127                                        i += 4;
     128                                        if(i < header_buf_used)
     129                                        {
     130                                                if(chunked)
     131                                                {
     132                                                        while(i<header_buf_used && isxdigit(header_buf[i]))
     133                                                        {
     134                                                                if(header_buf[i] >= '0' && header_buf[i] <= '9')
     135                                                                        chunksize = (chunksize << 4) + (header_buf[i] - '0');
     136                                                                else
     137                                                                        chunksize = (chunksize << 4) + ((header_buf[i] | 32) - 'a' + 10);
     138                                                                i++;
     139                                                        }
     140                                                        /* discarding chunk-extension */
     141                                                        while(i < header_buf_used && header_buf[i] != '\r') i++;
     142                                                        if(i < header_buf_used && header_buf[i] == '\r') i++;
     143                                                        if(i < header_buf_used && header_buf[i] == '\n') i++;
     144#ifdef DEBUG
     145                                                        printf("chunksize = %u (%x)\n", chunksize, chunksize);
     146#endif
     147                                                        if(chunksize == 0)
     148                                                        {
     149#ifdef DEBUG
     150                                                                printf("end of stream !\n");
     151#endif
     152                                                                goto end_of_stream;     
     153                                                        }
     154                                                        if(header_buf_used - i <= chunksize)
     155                                                        {
     156                                                                if(content_buf_len < header_buf_used - i)
     157                                                                {
     158                                                                        content_buf = realloc(content_buf, header_buf_used - i);
     159                                                                        content_buf_len = header_buf_used - i;
     160                                                                }
     161                                                                memcpy(content_buf, header_buf + i, header_buf_used - i);
     162                                                                content_buf_used = header_buf_used - i;
     163                                                                chunksize -= (header_buf_used - i);
     164                                                                i = header_buf_used;
     165                                                        }
     166                                                        else
     167                                                        {
     168                                                                printf("arg ! chunksize < (header_buf_used - i)\n");
     169                                                        }
     170                                                }
     171                                                else
     172                                                {
     173                                                        if(content_buf_len < header_buf_used - i)
     174                                                        {
     175                                                                content_buf = realloc(content_buf, header_buf_used - i);
     176                                                                content_buf_len = header_buf_used - i;
     177                                                        }
     178                                                        memcpy(content_buf, header_buf + i, header_buf_used - i);
     179                                                        content_buf_used = header_buf_used - i;
     180                                                }
     181                                        }
     182                                }
     183                        }
     184                }
     185                else
     186                {
     187                        /* content */
     188                        if(chunked)
     189                        {
     190                                int i = 0;
     191                                unsigned bytestocopy;
     192                                while(i < n)
     193                                {
     194                                        if(chunksize == 0)
     195                                        {
     196                                                /* reading chunk size */
     197                                                if(i<n && buf[i] == '\r') i++;
     198                                                if(i<n && buf[i] == '\n') i++;
     199                                                while(i<n && isxdigit(buf[i]))
     200                                                {
     201                                                        if(buf[i] >= '0' && buf[i] <= '9')
     202                                                                chunksize = (chunksize << 4) + (buf[i] - '0');
     203                                                        else
     204                                                                chunksize = (chunksize << 4) + ((buf[i] | 32) - 'a' + 10);
     205                                                        i++;
     206                                                }
     207                                                while(i<n && buf[i] != '\r') i++; /* discarding chunk-extension */
     208                                                if(i<n && buf[i] == '\r') i++;
     209                                                if(i<n && buf[i] == '\n') i++;
     210#ifdef DEBUG
     211                                                printf("chunksize = %u (%x)\n", chunksize, chunksize);
     212#endif
     213                                                if(chunksize == 0)
     214                                                {
     215#ifdef DEBUG
     216                                                        printf("end of stream - %d %d\n", i, n);
     217                                                        /*printf("'%.*s'\n", n-i, buf+i);*/
     218#endif
     219                                                        goto end_of_stream;
     220                                                }
     221                                        }
     222                                        bytestocopy = (chunksize < n - i)?chunksize:(n - i);
     223                                        if(content_buf_used + bytestocopy > content_buf_len)
     224                                        {
     225                                                content_buf = (char *)realloc((void *)content_buf,
     226                                                                              content_buf_used + bytestocopy);
     227                                                content_buf_len = content_buf_used + bytestocopy;
     228                                        }
     229                                        memcpy(content_buf + content_buf_used, buf + i, bytestocopy);
     230                                        content_buf_used += bytestocopy;
     231                                        i += bytestocopy;
     232                                        chunksize -= bytestocopy;
     233                                }
     234                        }
     235                        else
     236                        {
     237                                if(content_buf_used + n > content_buf_len)
     238                                {
     239                                        content_buf = (char *)realloc((void *)content_buf,
     240                                                                      content_buf_used + n);
     241                                        content_buf_len = content_buf_used + n;
     242                                }
     243                                memcpy(content_buf + content_buf_used, buf, n);
     244                                content_buf_used += n;
     245                        }
     246                }
     247                if(content_length > 0 && content_buf_used >= content_length)
     248                {
     249#ifdef DEBUG
     250                        printf("termine!\n");
     251#endif
     252                        break;
     253                }
     254        }
     255end_of_stream:
     256        free(header_buf); header_buf = NULL;
     257        *size = content_buf_used;
     258        if(content_buf_used == 0)
     259        {
     260                free(content_buf);
     261                content_buf = NULL;
     262        }
     263        return content_buf;
     264}
     265
    44266/* miniwget3() :
    45267 * do all the work.
     
    127349                }
    128350        }
    129         {
    130                 /* TODO : in order to support HTTP/1.1, chunked transfer encoding
    131                  *        must be supported. That means parsing of headers must be
    132                  *        added.                                                   */
    133                 int headers=1;
    134                 char * respbuffer = NULL;
    135                 int allreadyread = 0;
    136                 /*while((n = recv(s, buf, 2048, 0)) > 0)*/
    137                 while((n = ReceiveData(s, buf, 2048, 5000)) > 0)
    138                 {
    139                         if(headers)
    140                         {
    141                                 int i=0;
    142                                 while(i<n-3)
    143                                 {
    144                                         /* searching for the end of the HTTP headers */
    145                                         if(buf[i]=='\r' && buf[i+1]=='\n'
    146                                            && buf[i+2]=='\r' && buf[i+3]=='\n')
    147                                         {
    148                                                 headers = 0;    /* end */
    149                                                 if(i<n-4)
    150                                                 {
    151                                                         /* Copy the content into respbuffet */
    152                                                         respbuffer = (char *)realloc((void *)respbuffer,
    153                                                                                                                  allreadyread+(n-i-4));
    154                                                         memcpy(respbuffer+allreadyread, buf + i + 4, n-i-4);
    155                                                         allreadyread += (n-i-4);
    156                                                 }
    157                                                 break;
    158                                         }
    159                                         i++;
    160                                 }
    161                         }
    162                         else
    163                         {
    164                                 respbuffer = (char *)realloc((void *)respbuffer,
    165                                                                  allreadyread+n);
    166                                 memcpy(respbuffer+allreadyread, buf, n);
    167                                 allreadyread += n;
    168                         }
    169                 }
    170                 *size = allreadyread;
    171 #ifdef DEBUG
    172                 printf("%d bytes read\n", *size);
    173 #endif
    174                 closesocket(s);
    175                 return respbuffer;
    176         }
     351        return getHTTPResponse(s, size);
    177352}
    178353
     
    186361        char * respbuffer;
    187362
     363        respbuffer = miniwget3(url, host, port, path, size, addr_str, addr_str_len, "1.1");
     364/*
    188365        respbuffer = miniwget3(url, host, port, path, size, addr_str, addr_str_len, "1.0");
    189366        if (*size == 0)
     
    195372                respbuffer = miniwget3(url, host, port, path, size, addr_str, addr_str_len, "1.1");
    196373        }
     374*/
    197375        return respbuffer;
    198376}
  • trunk/third-party/miniupnp/miniwget.h

    r3731 r11510  
    1 /* $Id: miniwget.h,v 1.5 2007/01/29 20:27:23 nanard Exp $ */
     1/* $Id: miniwget.h,v 1.6 2010/12/09 16:11:33 nanard Exp $ */
    22/* Project : miniupnp
    33 * Author : Thomas Bernard
     
    1515#endif
    1616
     17LIBSPEC void * getHTTPResponse(int s, int * size);
     18
    1719LIBSPEC void * miniwget(const char *, int *);
    1820
Note: See TracChangeset for help on using the changeset viewer.