url.c File Reference

Production-grade URL parsing and validation using PCRE2. More...

Go to the source code of this file.

Functions
bool	url_is_valid (const char *url)
asciichat_error_t	url_parse (const char *url, url_parts_t *parts_out)
void	url_parts_destroy (url_parts_t *parts)
bool	url_is_websocket_scheme (const char *scheme)
bool	url_is_websocket (const char *url)
bool	url_looks_like_websocket (const char *url)

Detailed Description

Production-grade URL parsing and validation using PCRE2.

Implements robust HTTP(S) URL validation using the production-grade regex by Diego Perini (MIT License), compiled with PCRE2 and JIT for high performance.

Definition in file url.c.

Function Documentation

url_is_valid()

bool url_is_valid

(

const char *

url

)

Definition at line 81 of file url.c.

                                   {
  if (!url || !*url) {
    SET_ERRNO(ERROR_INVALID_PARAM, "URL is NULL or empty");
    return false;
  }
 
  pcre2_code *regex = url_regex_get();
  if (!regex) {
    return false;
  }
 
  /* Check if URL needs http:// prefix (bare hostname or IP) */
  char url_with_scheme[2048];
  const char *url_to_match = url;
 
  if (!strstr(url, "://")) {
    /* No scheme - check if it looks like a bare hostname/IP */
 
    /* Reject bare scheme words like "http", "https", "ftp" */
    if (strcmp(url, "http") == 0 || strcmp(url, "https") == 0 || strcmp(url, "ftp") == 0 || strcmp(url, "ftps") == 0) {
      return false;
    }
 
    /* Reject URLs that look like malformed schemes (http/ instead of http://) */
    if (strncmp(url, "http/", 5) == 0 || strncmp(url, "https/", 6) == 0) {
      return false;
    }
 
    /* Reject if it contains @ (email-like) */
    if (strchr(url, '@')) {
      return false;
    }
 
    /* Reject pure hex strings (raw keys, not hostnames) */
    if (strlen(url) == 64) {
      bool all_hex = true;
      for (const char *p = url; *p && all_hex; p++) {
        if (!((*p >= '0' && *p <= '9') || (*p >= 'a' && *p <= 'f') || (*p >= 'A' && *p <= 'F'))) {
          all_hex = false;
        }
      }
      if (all_hex) {
        return false; /* Looks like raw hex key, not hostname */
      }
    }
 
    /* Check colon handling */
    const char *colon_pos = strchr(url, ':');
    if (colon_pos) {
      /* Has colon - reject unless colon is followed by port number */
      const char *after_colon = colon_pos + 1;
      bool looks_like_port = true;
      for (const char *p = after_colon; *p && *p != '/'; p++) {
        if (!(*p >= '0' && *p <= '9')) {
          looks_like_port = false;
          break;
        }
      }
      if (!looks_like_port) {
        return false; /* Colon but not a port number */
      }
    }
 
    /* Looks like a bare hostname/IP - prepend http:// */
    int result = snprintf(url_with_scheme, sizeof(url_with_scheme), "http://%s", url);
    if (result < 0 || result >= (int)sizeof(url_with_scheme)) {
      return false; /* URL too long */
    }
    url_to_match = url_with_scheme;
  }
 
  pcre2_match_data *match_data = pcre2_match_data_create_from_pattern(regex, NULL);
  if (!match_data) {
    return false;
  }
 
  /* Perform JIT match (falls back to interpreted if JIT unavailable) */
  int rc = pcre2_jit_match(regex, (PCRE2_SPTR)url_to_match, strlen(url_to_match), 0, /* startoffset */
                           0,                                                        /* options */
                           match_data, NULL);                                        /* mcontext */
 
  pcre2_match_data_free(match_data);
  return rc >= 0; /* rc >= 0 means successful match */
}

Referenced by ffmpeg_decoder_create(), options_init(), parse_public_key(), and yt_dlp_extract_stream_url().

url_is_websocket()

bool url_is_websocket

(

const char *

url

)

Definition at line 307 of file url.c.

                                       {
  if (!url || !*url) {
    SET_ERRNO(ERROR_INVALID_PARAM, "url is NULL or empty");
    return false;
  }
 
  /* Parse URL to validate and check scheme */
  url_parts_t parts = {0};
  asciichat_error_t result = url_parse(url, &parts);
  bool is_ws = (result == ASCIICHAT_OK && url_is_websocket_scheme(parts.scheme));
  url_parts_destroy(&parts);
 
  return is_ws;
}

References url_is_websocket_scheme(), url_parse(), and url_parts_destroy().

Referenced by client_main(), connection_attempt_tcp(), server_connection_establish(), and session_client_like_run().

url_is_websocket_scheme()

bool url_is_websocket_scheme

(

const char *

scheme

)

Definition at line 297 of file url.c.

                                                 {
  if (!scheme || !*scheme) {
    SET_ERRNO(ERROR_INVALID_PARAM, "scheme is NULL or empty");
    return false;
  }
 
  /* Case-insensitive comparison for "ws" or "wss" */
  return (strcasecmp(scheme, "ws") == 0 || strcasecmp(scheme, "wss") == 0);
}

Referenced by url_is_websocket().

url_looks_like_websocket()

bool url_looks_like_websocket

(

const char *

url

)

Definition at line 322 of file url.c.

                                               {
  if (!url || !*url) {
    SET_ERRNO(ERROR_INVALID_PARAM, "url is NULL or empty");
    return false;
  }
 
  /* Quick check for ws:// or wss:// prefix (case-insensitive) */
  return (strncasecmp(url, "ws://", 5) == 0 || strncasecmp(url, "wss://", 6) == 0);
}

url_parse()

asciichat_error_t url_parse	(	const char *	url,
		url_parts_t *	parts_out
	)

Definition at line 166 of file url.c.

                                                                     {
  if (!url || !*url) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "URL is NULL or empty");
  }
 
  if (!parts_out) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "parts_out is NULL");
  }
 
  /* Clear output structure */
  memset(parts_out, 0, sizeof(*parts_out));
 
  pcre2_code *regex = url_regex_get();
  if (!regex) {
    return SET_ERRNO(ERROR_CONFIG, "URL validator not initialized");
  }
 
  /* Check if URL needs http:// prefix (bare hostname or IP) */
  // allocate twice the "safe limit" of 2048 for website URLs, even though modern browsers can handle up
  // to 80k character URLs in some cases.
  char url_with_scheme[4096];
  const char *url_to_match = url;
  const char *original_url = url;
 
  if (!strstr(url, "://")) {
    /* No scheme - check if it looks like a bare hostname/IP */
 
    /* Reject bare scheme words like "http", "https", "ftp" */
    if (strcmp(url, "http") == 0 || strcmp(url, "https") == 0 || strcmp(url, "ftp") == 0 || strcmp(url, "ftps") == 0) {
      return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid URL format: %s", url);
    }
 
    /* Reject URLs that look like malformed schemes (http/ instead of http://) */
    if (strncmp(url, "http/", 5) == 0 || strncmp(url, "https/", 6) == 0) {
      return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid URL format (looks like malformed scheme): %s", url);
    }
 
    /* Reject pure hex strings (raw keys, not hostnames) */
    if (strlen(url) == 64) {
      bool all_hex = true;
      for (const char *p = url; *p && all_hex; p++) {
        if (!((*p >= '0' && *p <= '9') || (*p >= 'a' && *p <= 'f') || (*p >= 'A' && *p <= 'F'))) {
          all_hex = false;
        }
      }
      if (all_hex) {
        return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid URL: appears to be raw hex data, not a URL");
      }
    }
 
    const char *colon_pos = strchr(url, ':');
    if (colon_pos) {
      /* Has colon - check if what follows is numeric (port) */
      const char *after_colon = colon_pos + 1;
      bool looks_like_port = true;
      for (const char *p = after_colon; *p && *p != '/'; p++) {
        if (!(*p >= '0' && *p <= '9')) {
          looks_like_port = false;
          break;
        }
      }
      if (!looks_like_port) {
        return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid URL format (invalid scheme): %s", url);
      }
    }
 
    /* Looks like a bare hostname/IP - prepend http:// */
    int result = snprintf(url_with_scheme, sizeof(url_with_scheme), "http://%s", url);
    if (result < 0 || result >= (int)sizeof(url_with_scheme)) {
      return SET_ERRNO(ERROR_INVALID_PARAM, "URL too long");
    }
    url_to_match = url_with_scheme;
  }
 
  pcre2_match_data *match_data = pcre2_match_data_create_from_pattern(regex, NULL);
  if (!match_data) {
    return SET_ERRNO(ERROR_MEMORY, "Failed to create match data");
  }
 
  /* Perform JIT match (falls back to interpreted if JIT unavailable) */
  int rc = pcre2_jit_match(regex, (PCRE2_SPTR)url_to_match, strlen(url_to_match), 0, /* startoffset */
                           0,                                                        /* options */
                           match_data, NULL);                                        /* mcontext */
 
  if (rc < 0) {
    pcre2_match_data_free(match_data);
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid URL format: %s", original_url);
  }
 
  /* Extract named groups */
  parts_out->scheme = asciichat_pcre2_extract_named_group(regex, match_data, "scheme", url_to_match);
  parts_out->userinfo = asciichat_pcre2_extract_named_group(regex, match_data, "userinfo", url_to_match);
  parts_out->host = asciichat_pcre2_extract_named_group(regex, match_data, "host", url_to_match);
  parts_out->ipv6 = asciichat_pcre2_extract_named_group(regex, match_data, "ipv6", url_to_match);
  parts_out->path = asciichat_pcre2_extract_named_group(regex, match_data, "path_query_fragment", url_to_match);
 
  /* Extract port number */
  parts_out->port = 0;
  char *port_str = asciichat_pcre2_extract_named_group(regex, match_data, "port", url_to_match);
  if (port_str) {
    parts_out->port = (int)strtol(port_str, NULL, 10);
    SAFE_FREE(port_str);
  }
 
  pcre2_match_data_free(match_data);
 
  /* Verify we got required fields */
  if (!parts_out->scheme || !parts_out->host) {
    url_parts_destroy(parts_out);
    return SET_ERRNO(ERROR_INVALID_PARAM, "Missing required URL components");
  }
 
  return ASCIICHAT_OK;
}

References asciichat_pcre2_extract_named_group(), and url_parts_destroy().

Referenced by connection_attempt_tcp(), parse_public_key(), server_connection_establish(), and url_is_websocket().

url_parts_destroy()

void url_parts_destroy

(

url_parts_t *

parts

)

Definition at line 281 of file url.c.

                                           {
  if (!parts) {
    SET_ERRNO(ERROR_INVALID_PARAM, "parts is NULL");
    return;
  }
 
  SAFE_FREE(parts->scheme);
  SAFE_FREE(parts->userinfo);
  SAFE_FREE(parts->host);
  SAFE_FREE(parts->ipv6);
  SAFE_FREE(parts->path);
  parts->port = 0;
 
  memset(parts, 0, sizeof(*parts));
}

Referenced by connection_attempt_tcp(), parse_public_key(), server_connection_establish(), url_is_websocket(), and url_parse().