[FFmpeg-devel,4/5] Implement logic to determine the IPFS gateway.

diff --git a/libavformat/ipfs.c b/libavformat/ipfs.c
index 22487c6cc8..8f6f91d85d 100644
--- a/libavformat/ipfs.c
+++ b/libavformat/ipfs.c
@@ -44,31 +44,166 @@  typedef struct Context {
     char *gateway;
 } Context;
 
+// A best-effort way to find the IPFS gateway.
+// Only the most appropiate gateway is set. It's not actually requested (http call) to prevent
+// potential slowdown in startup. A potential timeout is handled by the HTTP protocol.
+//
+// When done and the return value is 1, a potential IPFS Gateway is set in the gateway
+// variable in the inner URLContext.
+static int populate_ipfs_gateway(URLContext *h)
+{
+    Context *c = h->priv_data;
+    char *home_folder;
+    const char *ipfs_data_folder = "/.ipfs/";
+    char *ipfs_full_data_folder;
+    char *ipfs_gateway_file;
+    struct stat st;
+    int stat_ret = 0;
+    FILE *gateway_file;
+    char gateway_file_data[1000];
+
+    // First, test if there already is a path in c->gateway. If it is then it was provided as
+    // cli arument and should be used. It takes precdence.
+    if (c->gateway != NULL) {
+        return 1;
+    }
+
+    // Test $IPFS_GATEWAY
+    c->gateway = getenv("IPFS_GATEWAY");
+    if (c->gateway) {
+        return 1;
+    } else {
+        av_log(h, AV_LOG_DEBUG, "$IPFS_GATEWAY is empty.\n");
+    }
+
+    // We need to know the IPFS folder to - eventually - read the contents of the "gateway" file which would tell us the gateway to use.
+    ipfs_full_data_folder = getenv("IPFS_PATH");
+
+    if (!ipfs_full_data_folder) {
+        av_log(h, AV_LOG_DEBUG, "$IPFS_PATH is empty.\n");
+
+        // Try via the home folder
+        home_folder = getenv("HOME");
+        ipfs_full_data_folder = malloc(strlen(home_folder) + strlen(ipfs_data_folder) + 1);
+        strcpy(ipfs_full_data_folder, home_folder);
+        strcat(ipfs_full_data_folder, ipfs_data_folder);
+
+        // Stat the folder. It should exist in a default IPFS setup when run as local user.
+#ifndef _WIN32
+        stat_ret = stat(ipfs_full_data_folder, &st);
+#else
+        stat_ret = win32_stat(ipfs_full_data_folder, &st);
+#endif
+        if (stat_ret < 0) {
+            av_log(h, AV_LOG_DEBUG, "Unable to find IPFS folder. We tried:\n");
+            av_log(h, AV_LOG_DEBUG, "- $IPFS_PATH, which was empty.\n");
+            av_log(h, AV_LOG_DEBUG, "- $HOME/.ipfs (full uri: %s) which doesn't exist.\n", ipfs_full_data_folder);
+            return -1;
+        }
+    }
+
+    ipfs_gateway_file = malloc(strlen(ipfs_full_data_folder) + strlen("gateway") + 1);
+    strcpy(ipfs_gateway_file, ipfs_full_data_folder);
+    strcat(ipfs_gateway_file, "gateway");
+
+    // Stat the gateway file. If it doesn't exist we have no gateway. If it does, we might have one.
+#ifndef _WIN32
+    stat_ret = stat(ipfs_gateway_file, &st);
+#else
+    stat_ret = win32_stat(ipfs_gateway_file, &st);
+#endif
+    if (stat_ret < 0) {
+        av_log(h, AV_LOG_ERROR, "The IPFS gateway file (full uri: %s) doesn't exist. Is the gateway enabled?\n", ipfs_gateway_file);
+        return -1;
+    }
+
+    // Get the contents of the gateway file
+    gateway_file = av_fopen_utf8(ipfs_gateway_file, "r");
+    if (!gateway_file) {
+        av_log(h, AV_LOG_ERROR, "Unable to open the IPFS gateway file (full uri: %s).\n", ipfs_gateway_file);
+        return -1;
+    }
+
+    fscanf(gateway_file, "%[^\n]", gateway_file_data);
+    fclose(gateway_file);
+
+    if ((st.st_size < 1) || (strlen(gateway_file_data) < 1)) {
+        av_log(h, AV_LOG_ERROR, "The IPFS gateway file (full uri: %s) appears to be empty. Is the gateway started?\n", ipfs_gateway_file);
+        return -1;
+    }
+
+    // Copy the gateway url into c->gateway
+    c->gateway = malloc(strlen(gateway_file_data) + 1);
+    strcpy(c->gateway, gateway_file_data);
+    if (c->gateway) {
+        return 1;
+    } else {
+        av_log(h, AV_LOG_DEBUG, "Unknown error in the IPFS gateway file.\n");
+    }
+
+    return -1;
+}
+
+// For now just makes sure that the gateway ends in url we expect. Like http://localhost:8080/.
+// Explicitly with the traling slash.
+static void sanitize_ipfs_gateway(URLContext *h)
+{
+    Context *c = h->priv_data;
+    const char last_gateway_char = c->gateway[strlen(c->gateway) - 1];
+    char *sanitized_gateway = c->gateway;
+
+    if (last_gateway_char != '/') {
+        sanitized_gateway = malloc(strlen(c->gateway) + 2);
+        strcpy(sanitized_gateway, c->gateway);
+        strcat(sanitized_gateway, "/");
+    }
+
+    c->gateway = sanitized_gateway;
+}
+
 static int ipfs_open(URLContext *h, const char *uri, int flags, AVDictionary **options)
 {
-    const char *gatewaysuffix;
-    const char *protocolPathSuffix = "ipfs/";
+    const char *gateway_suffix;
+    const char *protocol_path_suffix = "ipfs/";
     int ret = 0;
     Context *c = h->priv_data;
-    int isIpfs = (av_strstart(uri, "ipfs://", &gatewaysuffix) || av_strstart(uri, "ipfs:", &gatewaysuffix));
-    int isIpns = (av_strstart(uri, "ipns://", &gatewaysuffix) || av_strstart(uri, "ipns:", &gatewaysuffix));
-    
-    if (!isIpfs && !isIpns) {
+    int is_ipfs = (av_strstart(uri, "ipfs://", &gateway_suffix) || av_strstart(uri, "ipfs:", &gateway_suffix));
+    int is_ipns = (av_strstart(uri, "ipns://", &gateway_suffix) || av_strstart(uri, "ipns:", &gateway_suffix));
+
+    // Populate the IPFS gateway if we have any.
+    // If not, inform the user how to properly set one.
+    if (populate_ipfs_gateway(h) < 0) {
+        av_log(h, AV_LOG_ERROR, "No IPFS gateway was set. Make sure a local IPFS instance is running.\n");
+        av_log(h, AV_LOG_INFO, "There are multiple options to define this gateway. The below options are in order of precedence:\n");
+        av_log(h, AV_LOG_INFO, "1. Define a -gateway <url> to the gateway without trailing forward slash.\n");
+        av_log(h, AV_LOG_INFO, "2. Define $IPFS_GATEWAY with the full http link to the gateway without trailing forward slash.\n");
+        av_log(h, AV_LOG_INFO, "3. Define $IPFS_PATH and point it to the IPFS data path.\n");
+        av_log(h, AV_LOG_INFO, "4. Have IPFS running in your local user folder (under $HOME/.ipfs).\n");
+        av_log(h, AV_LOG_INFO, "In all path cases, a file named gateway is expected. See https://github.com/ipfs/specs/issues/261 for more information.\n");
+        ret = AVERROR(EINVAL);
+        goto err;
+    }
+
+    // Sanitize the gateway to a format we expect.
+    sanitize_ipfs_gateway(h);
+
+    // We must have either ipns or ipfs.
+    if (!is_ipfs && !is_ipns) {
         ret = AVERROR(EINVAL);
         av_log(h, AV_LOG_ERROR, "Unsupported url %s\n", uri);
         goto err;
     }
 
     // If we have IPNS, update the protocol
-    if (isIpns) {
-        protocolPathSuffix = "ipns/";
+    if (is_ipns) {
+        protocol_path_suffix = "ipns/";
     }
 
     // Concatenate the url. This ends up with something like: http://localhost:8080/ipfs/Qm.....
-    c->fulluri = malloc(strlen(c->gateway) + strlen(protocolPathSuffix) + strlen(gatewaysuffix) + 1);
+    c->fulluri = malloc(strlen(c->gateway) + strlen(protocol_path_suffix) + strlen(gateway_suffix) + 1);
     strcpy(c->fulluri, c->gateway);
-    strcat(c->fulluri, protocolPathSuffix);
-    strcat(c->fulluri, gatewaysuffix);
+    strcat(c->fulluri, protocol_path_suffix);
+    strcat(c->fulluri, gateway_suffix);
     
     // Pass the URL back to FFMpeg's protocol handler.
     if ((ret = ffurl_open_whitelist(&c->inner, c->fulluri, flags,
@@ -115,7 +250,7 @@  static int ipfs_close(URLContext *h)
 #define OFFSET(x) offsetof(Context, x)
 
 static const AVOption options[] = {
-    {"gateway", "The gateway to ask for IPFS data.", OFFSET(gateway), AV_OPT_TYPE_STRING, {.str = "http://localhost:8080/"}, 0, 0, AV_OPT_FLAG_DECODING_PARAM },
+    {"gateway", "The gateway to ask for IPFS data.", OFFSET(gateway), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, AV_OPT_FLAG_DECODING_PARAM },
     {NULL},
 };