Ignore:
Timestamp:
Jun 4, 2009 3:11:25 PM (11 years ago)
Author:
bennylp
Message:

Ticket #878: New PJLIB API to parse socket address string

File:
1 edited

Legend:

Unmodified
Added
Removed
  • pjproject/trunk/pjlib/src/pjlib-test/sock.c

    r2394 r2743  
    168168    /* pj_gethostaddr() */ 
    169169 
     170 
     171    return 0; 
     172} 
     173 
     174static int parse_test(void) 
     175{ 
     176#define IPv4    1 
     177#define IPv6    2 
     178 
     179    struct test_t { 
     180        const char  *input; 
     181        int          result_af; 
     182        const char  *result_ip; 
     183        pj_uint16_t  result_port; 
     184    }; 
     185    struct test_t valid_tests[] =  
     186    { 
     187        /* IPv4 */ 
     188        { "10.0.0.1:80", IPv4, "10.0.0.1", 80}, 
     189        { "10.0.0.1", IPv4, "10.0.0.1", 0}, 
     190        { "10.0.0.1:", IPv4, "10.0.0.1", 0}, 
     191        { "10.0.0.1:0", IPv4, "10.0.0.1", 0}, 
     192        { ":80", IPv4, "0.0.0.0", 80}, 
     193        { ":", IPv4, "0.0.0.0", 0}, 
     194        { "localhost", IPv4, "127.0.0.1", 0}, 
     195        { "localhost:", IPv4, "127.0.0.1", 0}, 
     196        { "localhost:80", IPv4, "127.0.0.1", 80}, 
     197 
     198#if defined(PJ_HAS_IPV6) && PJ_HAS_IPV6 
     199        { "fe::01:80", IPv6, "fe::01:80", 0}, 
     200        { "[fe::01]:80", IPv6, "fe::01", 80}, 
     201        { "fe::01", IPv6, "fe::01", 0}, 
     202        { "[fe::01]", IPv6, "fe::01", 0}, 
     203        { "fe::01:", IPv6, "fe::01", 0}, 
     204        { "[fe::01]:", IPv6, "fe::01", 0}, 
     205        { "::", IPv6, "::0", 0}, 
     206        { "[::]", IPv6, "::", 0}, 
     207        { ":::", IPv6, "::", 0}, 
     208        { "[::]:", IPv6, "::", 0}, 
     209        { ":::80", IPv6, "::", 80}, 
     210        { "[::]:80", IPv6, "::", 80}, 
     211#endif 
     212    }; 
     213    struct test_t invalid_tests[] =  
     214    { 
     215        /* IPv4 */ 
     216        { "10.0.0.1:abcd", IPv4},   /* port not numeric */ 
     217        { "10.0.0.1:-1", IPv4},     /* port contains illegal character */ 
     218        { "10.0.0.1:123456", IPv4}, /* port too big     */ 
     219        { "1.2.3.4.5:80", IPv4},    /* invalid IP */ 
     220 
     221#if defined(PJ_HAS_IPV6) && PJ_HAS_IPV6 
     222        { "[fe::01]:abcd", IPv6},   /* port not numeric */ 
     223        { "[fe::01]:-1", IPv6},     /* port contains illegal character */ 
     224        { "[fe::01]:123456", IPv6}, /* port too big     */ 
     225        { "fe::01:02::03:04:80", IPv6},     /* invalid IP */ 
     226        { "[fe::01:02::03:04]:80", IPv6},   /* invalid IP */ 
     227        { "[fe:01", IPv6},          /* Unterminated bracket */ 
     228#endif 
     229    }; 
     230 
     231    unsigned i; 
     232 
     233    PJ_LOG(3,("test", "...IP address parsing")); 
     234 
     235    for (i=0; i<PJ_ARRAY_SIZE(valid_tests); ++i) { 
     236        pj_status_t status; 
     237        pj_str_t input; 
     238        pj_sockaddr addr, result; 
     239 
     240        switch (valid_tests[i].result_af) { 
     241        case IPv4: 
     242            valid_tests[i].result_af = PJ_AF_INET; 
     243            break; 
     244        case IPv6: 
     245            valid_tests[i].result_af = PJ_AF_INET6; 
     246            break; 
     247        default: 
     248            pj_assert(!"Invalid AF!"); 
     249            continue; 
     250        } 
     251 
     252        /* Try parsing with PJ_AF_UNSPEC */ 
     253        status = pj_sockaddr_parse(PJ_AF_UNSPEC, 0,  
     254                                   pj_cstr(&input, valid_tests[i].input),  
     255                                   &addr); 
     256        if (status != PJ_SUCCESS) { 
     257            PJ_LOG(1,("test", ".... failed when parsing %s",  
     258                      valid_tests[i].input)); 
     259            return -10; 
     260        } 
     261 
     262        /* Build the correct result */ 
     263        status = pj_sockaddr_init(valid_tests[i].result_af, 
     264                                  &result, 
     265                                  pj_cstr(&input, valid_tests[i].result_ip),  
     266                                  valid_tests[i].result_port); 
     267        if (status != PJ_SUCCESS) { 
     268            PJ_LOG(1,("test", ".... error building IP address %s",  
     269                      valid_tests[i].input)); 
     270            return -30; 
     271        } 
     272 
     273        /* Compare the result */ 
     274        if (pj_sockaddr_cmp(&addr, &result) != 0) { 
     275            PJ_LOG(1,("test", ".... parsed result mismatched for %s",  
     276                      valid_tests[i].input)); 
     277            return -40; 
     278        } 
     279 
     280        /* Parse again with the specified af */ 
     281        status = pj_sockaddr_parse(valid_tests[i].result_af, 0,  
     282                                   pj_cstr(&input, valid_tests[i].input),  
     283                                   &addr); 
     284        if (status != PJ_SUCCESS) { 
     285            PJ_LOG(1,("test", ".... failed when parsing %s",  
     286                      valid_tests[i].input)); 
     287            return -50; 
     288        } 
     289 
     290        /* Compare the result again */ 
     291        if (pj_sockaddr_cmp(&addr, &result) != 0) { 
     292            PJ_LOG(1,("test", ".... parsed result mismatched for %s",  
     293                      valid_tests[i].input)); 
     294            return -60; 
     295        } 
     296    } 
     297 
     298    for (i=0; i<PJ_ARRAY_SIZE(invalid_tests); ++i) { 
     299        pj_status_t status; 
     300        pj_str_t input; 
     301        pj_sockaddr addr; 
     302 
     303        switch (invalid_tests[i].result_af) { 
     304        case IPv4: 
     305            invalid_tests[i].result_af = PJ_AF_INET; 
     306            break; 
     307        case IPv6: 
     308            invalid_tests[i].result_af = PJ_AF_INET6; 
     309            break; 
     310        default: 
     311            pj_assert(!"Invalid AF!"); 
     312            continue; 
     313        } 
     314 
     315        /* Try parsing with PJ_AF_UNSPEC */ 
     316        status = pj_sockaddr_parse(PJ_AF_UNSPEC, 0,  
     317                                   pj_cstr(&input, invalid_tests[i].input),  
     318                                   &addr); 
     319        if (status == PJ_SUCCESS) { 
     320            PJ_LOG(1,("test", ".... expecting failure when parsing %s",  
     321                      invalid_tests[i].input)); 
     322            return -100; 
     323        } 
     324    } 
    170325 
    171326    return 0; 
     
    577732        return rc; 
    578733 
     734    rc = parse_test(); 
     735    if (rc != 0) 
     736        return rc; 
     737 
    579738    rc = gethostbyname_test(); 
    580739    if (rc != 0) 
Note: See TracChangeset for help on using the changeset viewer.