* src/ne_request.c (struct ne_request_s): Add target_uri field.

  (ne_get_response_location): Return const, cache the URI in
  req->target_uri.
  (ne_get_response_location): Update accordingly.

* test/request.c (targets): Update accordingly.

src/ne_request.c

@@ -160,6 +160,7 @@ struct ne_request_s {
  struct interim_handler *interim_handler;
 
  /*** Miscellaneous ***/
+ ne_uri *target_uri;
  unsigned int method_is_head;
  unsigned int can_persist;
 
@@ -582,16 +583,21 @@ static int get_request_target_uri(ne_request *req, ne_uri *uri)
  }
 }
 
-ne_uri *ne_get_request_target(ne_request *req)
+const ne_uri *ne_get_request_target(ne_request *req)
 {
- ne_uri *rv = ne_calloc(sizeof *rv);
+ if (req->target_uri == NULL) {
+ ne_uri *uri = ne_calloc(sizeof *uri);
 
- if (get_request_target_uri(req, rv)) {
- ne_uri_free(rv);
- return NULL;
+ if (get_request_target_uri(req, uri) == 0) {
+ req->target_uri = uri;
+ }
+ else {
+ ne_uri_free(uri);
+ ne_free(uri);
+ }
  }
 
- return rv;
+ return req->target_uri;
 }
 
 /* Set the request body length to 'length' */
@@ -762,13 +768,13 @@ static void free_response_headers(ne_request *req)
 ne_uri *ne_get_response_location(ne_request *req, const char *fragment)
 {
  const char *location;
- ne_uri dest, base, *ret = NULL;
+ ne_uri dest, *ret = NULL;
+ const ne_uri *base;
 
  location = get_response_header_hv(req, HH_HV_LOCATION, "location");
  if (location == NULL)
  return NULL;
 
- memset(&base, 0, sizeof base);
  memset(&dest, 0, sizeof dest);
 
  /* Location is a URI-reference (RFC9110ẞ10.2.2) relative to the
@@ -781,22 +787,21 @@ ne_uri *ne_get_response_location(ne_request *req, const char *fragment)
  goto fail;
  }
 
- if (get_request_target_uri(req, &base)) {
- ne_set_error(req->session, _("Could not parse redirect "
- "destination URL"));
+ if ((base = ne_get_request_target(req)) == NULL) {
+ ne_set_error(req->session, _("Could not parse request "
+ "target URI"));
  goto fail;
  }
 
  ret = ne_malloc(sizeof *ret);
- ne_uri_resolve(&base, &dest, ret);
+ ne_uri_resolve(base, &dest, ret);
 
  /* HTTP-specific fragment handling is a MUST in RFC9110ẞ10.2.2: */
  if (fragment && !dest.fragment) {
  ret->fragment = ne_strdup(fragment);
  }
 
 fail:
- ne_uri_free(&base);
  ne_uri_free(&dest);
 
  return ret;
@@ -832,6 +837,10 @@ void ne_request_destroy(ne_request *req)
 
  ne_free(req->target);
  ne_free(req->method);
+ if (req->target_uri) {
+ ne_uri_free(req->target_uri);
+ ne_free(req->target_uri);
+ }
 
  for (rdr = req->body_readers; rdr != NULL; rdr = next_rdr) {
  next_rdr = rdr->next;

src/ne_request.h

@@ -169,7 +169,7 @@ void ne_print_request_header(ne_request *req, const char *name,
 /* Returns the request target URI as a malloc-allocated ne_uri object,
  * or NULL on error if the request target cannot be determined. The
  * session error string is not changed on error. */
-ne_uri *ne_get_request_target(ne_request *req);
+const ne_uri *ne_get_request_target(ne_request *req);
 
 /* If the response includes a Location header, this function parses
  * and resolves the URI-reference relative to the request target. If

test/request.c

@@ -2455,23 +2455,22 @@ static int targets(void)
  unsigned n;
 
  for (n = 0; ts[n].scheme != NULL; n++ ) {
+ const ne_uri *uri, *uri2;
  ne_session *sess;
  ne_request *req;
- ne_uri *uri;
  char *actual;
 
  sess = ne_session_create(ts[n].scheme, ts[n].host, ts[n].port);
  req = ne_request_create(sess, ts[n].method, ts[n].target);
  uri = ne_get_request_target(req);
+ uri2 = ne_get_request_target(req);
  actual = uri ? ne_uri_unparse(uri) : NULL;
 
  ONCMP(ts[n].expected, actual, "request target", "URI");
 
+ ONN("caching failed, different rv on second call", uri != uri2);
+
  if (actual) ne_free(actual);
- if (uri) {
- ne_uri_free(uri);
- ne_free(uri);
- }
 
  ne_request_destroy(req);
  ne_session_destroy(sess);