pathHead is null after parsing "http:/"

[erwee]

On versions 8.4.0 and 8.5.0, the following code will fail on the second assert:

    const char* url = "http:/";
    UriParserStateA state;
    UriUriA uriStruct;
    state.uri = &uriStruct;
    int err = uriParseUriA(&state, url);
    assert(err == URI_SUCCESS);
    assert(uriStruct.pathHead != NULL); // this fails

I'm expecting the pathHead to be non-null, because the input string matches the (scheme ":" path-absolute) form of the URI grammar. Also, I'm expecting the first path-segment to be an empty string.

If I changed the input string to "http:/path", or to "http:///", the above test passes.

[hartwork]

Before I get to take a closer look to confirm or not confirm this as a bug, let me share this shell output:

# ./uriparse http:
uri:          http:                                                                                                                                                                           
scheme:       http                                                                                                                                                                            
absolutePath: false                                                                                                                                                                           
                                                                                                                                                                                              
# ./uriparse http:/                                                                                                                                                                           
uri:          http:/                                                                                                                                                                          
scheme:       http                                                                                                                                                                            
absolutePath: true                                                                                                                                                                            
                                                                                                                                                                                              
# ./uriparse http:/a                                                                                                                                                                          
uri:          http:/a                                                                                                                                                                         
scheme:       http                                                                                                                                                                            
 .. pathSeg:  a                                                                                                                                                                               
absolutePath: true

[hartwork]

I guess I can acknowledge absolutePath as a suboptimal design but I'm tending towards: bad design, not a bug (that we could fix (without breaking ABI and making things worse)).

[erwee]

I suppose the problem I'm having with this is that the resulting value of pathHead after parsing a path consisting of a single "/" is not consistent between different forms of URI hier-parts. For example, for "http:///", pathHead is non-null, and pathSegment is an empty string, whereas for "http:/", pathHead comes out as NULL.

[hartwork]

Could be more fun, agreed. Without breaking ABI (or even API), we cannot do anything about it, right?

[erwee]

Ok fine, then I guess if someone needs to check if a URI has a path, then he'd have to check both pathAbsolute flag and the pathHead pointer to see if either of them is true/non-null.. Because pathHead alone is not enough.. Might need to document this.

[hartwork]

I found this comment block from 55ea6ab in the test suite:

============================================================================
Rule                                | Example | hostSet | absPath | emptySeg
------------------------------------|---------|---------|---------|---------
1) URI = scheme ":" hier-part ...   |         |         |         |
   1) "//" authority path-abempty   | "s://"  | true    |   false |   false
                                    | "s:///" | true    |   false | true
                                    | "s://a" | true    |   false |   false
                                    | "s://a/"| true    |   false | true
   2) path-absolute                 | "s:/"   |   false | true    |   false
   3) path-rootless                 | "s:a"   |   false |   false |   false
                                    | "s:a/"  |   false |   false | true
   4) path-empty                    | "s:"    |   false |   false |   false
------------------------------------|---------|---------|---------|---------
2) relative-ref = relative-part ... |         |         |         |
   1) "//" authority path-abempty   | "//"    | true    |   false |   false
                                    | "///"   | true    |   false | true
   2) path-absolute                 | "/"     |   false | true    |   false
   3) path-noscheme                 | "a"     |   false |   false |   false
                                    | "a/"    |   false |   false | true
   4) path-empty                    | ""      |   false |   false |   false
============================================================================

I guess it could use more visibility, sorry.