Changeset 8462


Ignore:
Timestamp:
May 21, 2009, 4:39:54 PM (12 years ago)
Author:
charles
Message:

(trunk dht) sync with upstream code @ http://www.pps.jussieu.fr/~jch/software/repos/dht/

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/third-party/dht/dht.c

    r8451 r8462  
    4646#include "dht.h"
    4747
    48 #ifndef HAVE_MEMMEM 
    49 #ifdef __GLIBC__ 
    50 #define HAVE_MEMMEM 
    51 #endif 
    52 #endif 
     48#ifndef HAVE_MEMMEM
     49#ifdef __GLIBC__
     50#define HAVE_MEMMEM
     51#endif
     52#endif
    5353
    5454#ifndef MSG_CONFIRM
     
    13681368    if(leaky_bucket_tokens == 0) {
    13691369        leaky_bucket_tokens = MIN(MAX_LEAKY_BUCKET_TOKENS,
    1370                                   2 * (now.tv_sec - leaky_bucket_time));
     1370                                  4 * (now.tv_sec - leaky_bucket_time));
    13711371        leaky_bucket_time = now.tv_sec;
    13721372    }
     
    13881388        int rc, i, message;
    13891389        unsigned char tid[16], id[20], info_hash[20], target[20];
    1390         unsigned char buf[1024], nodes[256], token[128];
     1390        unsigned char buf[1536], nodes[256], token[128];
    13911391        int tid_len = 16, token_len = 128;
    13921392        int nodes_len = 256;
     
    13981398        unsigned short ttid;
    13991399
    1400         rc = recvfrom(s, buf, 1024, 0,
     1400        rc = recvfrom(s, buf, 1536, 0,
    14011401                      (struct sockaddr*)&source, &source_len);
    14021402        if(rc < 0) {
     
    14201420                goto dontread;
    14211421            }
     1422        }
     1423
     1424        /* There's a bug in parse_message -- it will happily overflow the
     1425           buffer if it's not NUL-terminated.  For now, put a NUL at the
     1426           end of buffers. */
     1427
     1428        if(rc < 1536) {
     1429            buf[rc] = '\0';
     1430        } else {
     1431            debugf("Overlong message.\n");
     1432            goto dontread;
    14221433        }
    14231434
     
    20862097}
    20872098
    2088 #ifndef HAVE_MEMMEM
    2089 static void *
    2090 memmem(const void *haystack, size_t haystacklen,
    2091        const void *needle, size_t needlelen)
    2092 {
    2093     const char *h = haystack;
    2094     const char *n = needle;
    2095     size_t i;
    2096 
    2097     for(i = 0; i < haystacklen - needlelen; i++) {
    2098         if(memcmp(h + i, n, needlelen) == 0)
     2099#undef CHECK
     2100#undef INC
     2101#undef COPY
     2102#undef ADD_V
     2103
     2104#ifndef HAVE_MEMMEM
     2105static void *
     2106memmem(const void *haystack, size_t haystacklen,
     2107       const void *needle, size_t needlelen)
     2108{
     2109    const char *h = haystack;
     2110    const char *n = needle;
     2111    size_t i;
     2112
     2113    for(i = 0; i < haystacklen - needlelen; i++) {
     2114        if(memcmp(h + i, n, needlelen) == 0)
    20992115            return (void*)(h + i);
    2100     } 
    2101     return NULL; 
    2102 } 
    2103 #endif 
     2116    }
     2117    return NULL;
     2118}
     2119#endif
    21042120
    21052121static int
     
    21142130    const unsigned char *p;
    21152131
     2132#define CHECK(ptr, len)                                                 \
     2133    if(((unsigned char*)ptr) + (len) > (buf) + (buflen)) goto overflow;
     2134
    21162135    if(tid_return) {
    21172136        p = memmem(buf, buflen, "1:t", 3);
     
    21212140            l = strtol((char*)p + 3, &q, 10);
    21222141            if(q && *q == ':' && l > 0 && l < *tid_len) {
     2142                CHECK(q + 1, l);
    21232143                memcpy(tid_return, q + 1, l);
    21242144                *tid_len = l;
     
    21302150        p = memmem(buf, buflen, "2:id20:", 7);
    21312151        if(p) {
     2152            CHECK(p + 7, 20);
    21322153            memcpy(id_return, p + 7, 20);
    21332154        } else {
     
    21382159        p = memmem(buf, buflen, "9:info_hash20:", 14);
    21392160        if(p) {
     2161            CHECK(p + 14, 20);
    21402162            memcpy(info_hash_return, p + 14, 20);
    21412163        } else {
     
    21592181        p = memmem(buf, buflen, "6:target20:", 11);
    21602182        if(p) {
     2183            CHECK(p + 11, 20);
    21612184            memcpy(target_return, p + 11, 20);
    21622185        } else {
     
    21712194            l = strtol((char*)p + 7, &q, 10);
    21722195            if(q && *q == ':' && l > 0 && l < *token_len) {
     2196                CHECK(q + 1, l);
    21732197                memcpy(token_return, q + 1, l);
    21742198                *token_len = l;
     
    21862210            l = strtol((char*)p + 7, &q, 10);
    21872211            if(q && *q == ':' && l > 0 && l < *nodes_len) {
     2212                CHECK(q + 1, l);
    21882213                memcpy(nodes_return, q + 1, l);
    21892214                *nodes_len = l;
     
    22022227                if(j + 6 > *values_len)
    22032228                    break;
     2229                CHECK(buf + i + 2, 6);
    22042230                memcpy((char*)values_return + j, buf + i + 2, 6);
    22052231                i += 8;
    22062232                j += 6;
    22072233            }
    2208             if(buf[i] != 'e')
    2209                 debugf("Eek... unexpected end for values.\n");
     2234            if(i >= buflen || buf[i] != 'e')
     2235                debugf("eek... unexpected end for values.\n");
    22102236            *values_len = j;
    22112237        } else {
     
    22132239        }
    22142240    }
     2241
     2242#undef CHECK
    22152243               
    22162244    if(memmem(buf, buflen, "1:y1:r", 6))
     
    22272255       return ANNOUNCE_PEER;
    22282256    return -1;
    2229 }
     2257
     2258 overflow:
     2259    debugf("Truncated message.\n");
     2260    return -1;
     2261}
Note: See TracChangeset for help on using the changeset viewer.