src: rename curlx_safefree to tool_safefree

It is not part of the curlx function collection, just a macro that might
as well be a local version.

Closes #17270

diff --git a/lib/curlx/curlx.h b/lib/curlx/curlx.h
index 73ea05a0feea3fe601b790fd9745f19f6fe466e8..89d54135b4f61cab8d4f3af0d4c43f0cc6e2ff52 100644 (file)
--- a/lib/curlx/curlx.h
+++ b/lib/curlx/curlx.h
@@ -67,6 +67,4 @@
 
 #include "../curl_get_line.h"
 
-#define curlx_safefree(x) Curl_safefree(x)
-
 #endif /* HEADER_CURL_CURLX_H */

diff --git a/src/tool_cb_hdr.c b/src/tool_cb_hdr.c
index 9dd8f2b7a30f11034cab045f64da1cc83bd38b3d..92952f2ff315d5f45658e01a114355f188b4370a 100644 (file)
--- a/src/tool_cb_hdr.c
+++ b/src/tool_cb_hdr.c
@@ -351,7 +351,7 @@ static char *parse_filename(const char *ptr, size_t len)
   if(q) {
     p = q + 1;
     if(!*p) {
-      curlx_safefree(copy);
+      tool_safefree(copy);
       return NULL;
     }
   }
@@ -363,7 +363,7 @@ static char *parse_filename(const char *ptr, size_t len)
   if(q) {
     p = q + 1;
     if(!*p) {
-      curlx_safefree(copy);
+      tool_safefree(copy);
       return NULL;
     }
   }
@@ -384,7 +384,7 @@ static char *parse_filename(const char *ptr, size_t len)
   {
     char *sanitized;
     SANITIZEcode sc = sanitize_file_name(&sanitized, copy, 0);
-    curlx_safefree(copy);
+    tool_safefree(copy);
     if(sc)
       return NULL;
     copy = sanitized;

diff --git a/src/tool_cfgable.c b/src/tool_cfgable.c
index e30925dd54caafa353c5c5dbc59d0c4f198f0c1b..99fc91b097243bae3a4c601b49db3abb6f06ae38 100644 (file)
--- a/src/tool_cfgable.c
+++ b/src/tool_cfgable.c
@@ -53,57 +53,57 @@ static void free_config_fields(struct OperationConfig *config)
 {
   struct getout *urlnode;
 
-  curlx_safefree(config->useragent);
-  curlx_safefree(config->altsvc);
-  curlx_safefree(config->hsts);
-  curlx_safefree(config->haproxy_clientip);
+  tool_safefree(config->useragent);
+  tool_safefree(config->altsvc);
+  tool_safefree(config->hsts);
+  tool_safefree(config->haproxy_clientip);
   curl_slist_free_all(config->cookies);
-  curlx_safefree(config->cookiejar);
+  tool_safefree(config->cookiejar);
   curl_slist_free_all(config->cookiefiles);
 
   curlx_dyn_free(&config->postdata);
-  curlx_safefree(config->query);
-  curlx_safefree(config->referer);
+  tool_safefree(config->query);
+  tool_safefree(config->referer);
 
-  curlx_safefree(config->headerfile);
-  curlx_safefree(config->ftpport);
-  curlx_safefree(config->iface);
+  tool_safefree(config->headerfile);
+  tool_safefree(config->ftpport);
+  tool_safefree(config->iface);
 
-  curlx_safefree(config->range);
+  tool_safefree(config->range);
 
-  curlx_safefree(config->userpwd);
-  curlx_safefree(config->tls_username);
-  curlx_safefree(config->tls_password);
-  curlx_safefree(config->tls_authtype);
-  curlx_safefree(config->proxy_tls_username);
-  curlx_safefree(config->proxy_tls_password);
-  curlx_safefree(config->proxy_tls_authtype);
-  curlx_safefree(config->proxyuserpwd);
-  curlx_safefree(config->proxy);
+  tool_safefree(config->userpwd);
+  tool_safefree(config->tls_username);
+  tool_safefree(config->tls_password);
+  tool_safefree(config->tls_authtype);
+  tool_safefree(config->proxy_tls_username);
+  tool_safefree(config->proxy_tls_password);
+  tool_safefree(config->proxy_tls_authtype);
+  tool_safefree(config->proxyuserpwd);
+  tool_safefree(config->proxy);
 
-  curlx_safefree(config->dns_ipv6_addr);
-  curlx_safefree(config->dns_ipv4_addr);
-  curlx_safefree(config->dns_interface);
-  curlx_safefree(config->dns_servers);
+  tool_safefree(config->dns_ipv6_addr);
+  tool_safefree(config->dns_ipv4_addr);
+  tool_safefree(config->dns_interface);
+  tool_safefree(config->dns_servers);
 
-  curlx_safefree(config->noproxy);
+  tool_safefree(config->noproxy);
 
-  curlx_safefree(config->mail_from);
+  tool_safefree(config->mail_from);
   curl_slist_free_all(config->mail_rcpt);
-  curlx_safefree(config->mail_auth);
+  tool_safefree(config->mail_auth);
 
-  curlx_safefree(config->netrc_file);
-  curlx_safefree(config->output_dir);
-  curlx_safefree(config->proto_str);
-  curlx_safefree(config->proto_redir_str);
+  tool_safefree(config->netrc_file);
+  tool_safefree(config->output_dir);
+  tool_safefree(config->proto_str);
+  tool_safefree(config->proto_redir_str);
 
   urlnode = config->url_list;
   while(urlnode) {
     struct getout *next = urlnode->next;
-    curlx_safefree(urlnode->url);
-    curlx_safefree(urlnode->outfile);
-    curlx_safefree(urlnode->infile);
-    curlx_safefree(urlnode);
+    tool_safefree(urlnode->url);
+    tool_safefree(urlnode->outfile);
+    tool_safefree(urlnode->infile);
+    tool_safefree(urlnode);
     urlnode = next;
   }
   config->url_list = NULL;
@@ -112,47 +112,47 @@ static void free_config_fields(struct OperationConfig *config)
   config->url_out = NULL;
 
 #ifndef CURL_DISABLE_IPFS
-  curlx_safefree(config->ipfs_gateway);
+  tool_safefree(config->ipfs_gateway);
 #endif /* !CURL_DISABLE_IPFS */
-  curlx_safefree(config->doh_url);
-  curlx_safefree(config->cipher_list);
-  curlx_safefree(config->proxy_cipher_list);
-  curlx_safefree(config->cipher13_list);
-  curlx_safefree(config->proxy_cipher13_list);
-  curlx_safefree(config->cert);
-  curlx_safefree(config->proxy_cert);
-  curlx_safefree(config->cert_type);
-  curlx_safefree(config->proxy_cert_type);
-  curlx_safefree(config->cacert);
-  curlx_safefree(config->login_options);
-  curlx_safefree(config->proxy_cacert);
-  curlx_safefree(config->capath);
-  curlx_safefree(config->proxy_capath);
-  curlx_safefree(config->crlfile);
-  curlx_safefree(config->pinnedpubkey);
-  curlx_safefree(config->proxy_pinnedpubkey);
-  curlx_safefree(config->proxy_crlfile);
-  curlx_safefree(config->key);
-  curlx_safefree(config->proxy_key);
-  curlx_safefree(config->key_type);
-  curlx_safefree(config->proxy_key_type);
-  curlx_safefree(config->key_passwd);
-  curlx_safefree(config->proxy_key_passwd);
-  curlx_safefree(config->pubkey);
-  curlx_safefree(config->hostpubmd5);
-  curlx_safefree(config->hostpubsha256);
-  curlx_safefree(config->engine);
-  curlx_safefree(config->etag_save_file);
-  curlx_safefree(config->etag_compare_file);
-  curlx_safefree(config->ssl_ec_curves);
-  curlx_safefree(config->request_target);
-  curlx_safefree(config->customrequest);
-  curlx_safefree(config->krblevel);
-  curlx_safefree(config->oauth_bearer);
-  curlx_safefree(config->sasl_authzid);
-  curlx_safefree(config->unix_socket_path);
-  curlx_safefree(config->writeout);
-  curlx_safefree(config->proto_default);
+  tool_safefree(config->doh_url);
+  tool_safefree(config->cipher_list);
+  tool_safefree(config->proxy_cipher_list);
+  tool_safefree(config->cipher13_list);
+  tool_safefree(config->proxy_cipher13_list);
+  tool_safefree(config->cert);
+  tool_safefree(config->proxy_cert);
+  tool_safefree(config->cert_type);
+  tool_safefree(config->proxy_cert_type);
+  tool_safefree(config->cacert);
+  tool_safefree(config->login_options);
+  tool_safefree(config->proxy_cacert);
+  tool_safefree(config->capath);
+  tool_safefree(config->proxy_capath);
+  tool_safefree(config->crlfile);
+  tool_safefree(config->pinnedpubkey);
+  tool_safefree(config->proxy_pinnedpubkey);
+  tool_safefree(config->proxy_crlfile);
+  tool_safefree(config->key);
+  tool_safefree(config->proxy_key);
+  tool_safefree(config->key_type);
+  tool_safefree(config->proxy_key_type);
+  tool_safefree(config->key_passwd);
+  tool_safefree(config->proxy_key_passwd);
+  tool_safefree(config->pubkey);
+  tool_safefree(config->hostpubmd5);
+  tool_safefree(config->hostpubsha256);
+  tool_safefree(config->engine);
+  tool_safefree(config->etag_save_file);
+  tool_safefree(config->etag_compare_file);
+  tool_safefree(config->ssl_ec_curves);
+  tool_safefree(config->request_target);
+  tool_safefree(config->customrequest);
+  tool_safefree(config->krblevel);
+  tool_safefree(config->oauth_bearer);
+  tool_safefree(config->sasl_authzid);
+  tool_safefree(config->unix_socket_path);
+  tool_safefree(config->writeout);
+  tool_safefree(config->proto_default);
 
   curl_slist_free_all(config->quote);
   curl_slist_free_all(config->postquote);
@@ -171,17 +171,17 @@ static void free_config_fields(struct OperationConfig *config)
   curl_slist_free_all(config->resolve);
   curl_slist_free_all(config->connect_to);
 
-  curlx_safefree(config->preproxy);
-  curlx_safefree(config->proxy_service_name);
-  curlx_safefree(config->service_name);
-  curlx_safefree(config->ftp_account);
-  curlx_safefree(config->ftp_alternative_to_user);
-  curlx_safefree(config->aws_sigv4);
-  curlx_safefree(config->proto_str);
-  curlx_safefree(config->proto_redir_str);
-  curlx_safefree(config->ech);
-  curlx_safefree(config->ech_config);
-  curlx_safefree(config->ech_public);
+  tool_safefree(config->preproxy);
+  tool_safefree(config->proxy_service_name);
+  tool_safefree(config->service_name);
+  tool_safefree(config->ftp_account);
+  tool_safefree(config->ftp_alternative_to_user);
+  tool_safefree(config->aws_sigv4);
+  tool_safefree(config->proto_str);
+  tool_safefree(config->proto_redir_str);
+  tool_safefree(config->ech);
+  tool_safefree(config->ech_config);
+  tool_safefree(config->ech_public);
 }
 
 void config_free(struct OperationConfig *config)

diff --git a/src/tool_cfgable.h b/src/tool_cfgable.h
index 15b2c347ead8cbc6efe0c6aeb5f9085e8813b869..0a64e7cb312229a0a63ada08a72f64800e4f00ef 100644 (file)
--- a/src/tool_cfgable.h
+++ b/src/tool_cfgable.h
@@ -59,6 +59,9 @@
 
 #define checkprefix(a,b)    curl_strnequal(b, STRCONST(a))
 
+#define tool_safefree(ptr)                      \
+  do { free((ptr)); (ptr) = NULL;} while(0)
+
 struct GlobalConfig;
 
 struct State {

diff --git a/src/tool_doswin.c b/src/tool_doswin.c
index 0b3f0ca9c781dd0e6b11a36c568ce89305316831..46993e43c71de634947cfc9266d1a1673d91d80d 100644 (file)
--- a/src/tool_doswin.c
+++ b/src/tool_doswin.c
@@ -594,7 +594,7 @@ CURLcode FindWin32CACert(struct OperationConfig *config,
   res_len = SearchPath(NULL, bundle_file, NULL, PATH_MAX, buf, &ptr);
   if(res_len > 0) {
     char *mstr = curlx_convert_tchar_to_UTF8(buf);
-    curlx_safefree(config->cacert);
+    tool_safefree(config->cacert);
     if(mstr)
       config->cacert = strdup(mstr);
     curlx_unicodefree(mstr);

diff --git a/src/tool_formparse.c b/src/tool_formparse.c
index 7f6af798930a202bf6e5ba26076628d9693ac784..2273b69dd301432b56e6e5a07476e1f80ecfc05b 100644 (file)
--- a/src/tool_formparse.c
+++ b/src/tool_formparse.c
@@ -169,7 +169,7 @@ static struct tool_mime *tool_mime_new_filedata(struct tool_mime *parent,
     }
     m = tool_mime_new(parent, TOOLMIME_STDIN);
     if(!m)
-      curlx_safefree(data);
+      tool_safefree(data);
     else {
       m->data = data;
       m->origin = origin;
@@ -190,11 +190,11 @@ void tool_mime_free(struct tool_mime *mime)
       tool_mime_free(mime->subparts);
     if(mime->prev)
       tool_mime_free(mime->prev);
-    curlx_safefree(mime->name);
-    curlx_safefree(mime->filename);
-    curlx_safefree(mime->type);
-    curlx_safefree(mime->encoder);
-    curlx_safefree(mime->data);
+    tool_safefree(mime->name);
+    tool_safefree(mime->filename);
+    tool_safefree(mime->type);
+    tool_safefree(mime->encoder);
+    tool_safefree(mime->data);
     curl_slist_free_all(mime->headers);
     free(mime);
   }
@@ -836,7 +836,7 @@ int formparse(struct OperationConfig *config,
                   "error while reading standard input");
             goto fail;
           }
-          curlx_safefree(part->data);
+          tool_safefree(part->data);
           part->size = -1;
           res = CURLE_OK;
         }
@@ -872,7 +872,7 @@ int formparse(struct OperationConfig *config,
                   "error while reading standard input");
             goto fail;
           }
-          curlx_safefree(part->data);
+          tool_safefree(part->data);
           part->size = -1;
           res = CURLE_OK;
         }
@@ -914,7 +914,7 @@ int formparse(struct OperationConfig *config,
   }
   err = 0;
 fail:
-  curlx_safefree(contents);
+  tool_safefree(contents);
   curl_slist_free_all(headers);
   return err;
 }

diff --git a/src/tool_getparam.c b/src/tool_getparam.c
index efa7145892e520c6b148934df3dfacb2170697e5..6631c0c67f3ce10fdd85abfa0ece7615e20a982a 100644 (file)
--- a/src/tool_getparam.c
+++ b/src/tool_getparam.c
@@ -659,7 +659,7 @@ static ParameterError data_urlencode(struct GlobalConfig *global,
   }
   else {
     char *enc = curl_easy_escape(NULL, postdata, (int)size);
-    curlx_safefree(postdata); /* no matter if it worked or not */
+    tool_safefree(postdata); /* no matter if it worked or not */
     if(enc) {
       char *n;
       replace_url_encoded_space_by_plus(enc);
@@ -953,7 +953,7 @@ static ParameterError set_data(cmdline_t cmd,
   if(!err && curlx_dyn_addn(&config->postdata, postdata, size))
     err = PARAM_NO_MEM;
 
-  curlx_safefree(postdata);
+  tool_safefree(postdata);
 
   config->postfields = curlx_dyn_ptr(&config->postdata);
   return err;
@@ -1553,7 +1553,7 @@ static ParameterError parse_writeout(struct GlobalConfig *global,
         return PARAM_READ_ERROR;
       }
     }
-    curlx_safefree(config->writeout);
+    tool_safefree(config->writeout);
     err = file2string(&config->writeout, file);
     if(file && (file != stdin))
       fclose(file);
@@ -1862,7 +1862,7 @@ ParameterError getparameter(const char *flag, /* f or -long-flag */
       err = getstr(&config->doh_url, nextarg, ALLOW_BLANK);
       if(!err && config->doh_url && !config->doh_url[0])
         /* if given a blank string, make it NULL again */
-        curlx_safefree(config->doh_url);
+        tool_safefree(config->doh_url);
       break;
     case C_CIPHERS: /* -- ciphers */
       err = getstr(&config->cipher_list, nextarg, DENY_BLANK);
@@ -2051,7 +2051,7 @@ ParameterError getparameter(const char *flag, /* f or -long-flag */
               a->lname);
       break;
     case C_FTP_PASV: /* --ftp-pasv */
-      curlx_safefree(config->ftpport);
+      tool_safefree(config->ftpport);
       break;
     case C_SOCKS5: /* --socks5 */
       /*  socks5 proxy to use, and resolves the name locally and passes on the

diff --git a/src/tool_ipfs.c b/src/tool_ipfs.c
index 484efb8c464ceb1f4bada0619163ded593935638..0d870bef3087228c6eac2b61b201c94d30f9576d 100644 (file)
--- a/src/tool_ipfs.c
+++ b/src/tool_ipfs.c
@@ -41,11 +41,11 @@ static CURLcode ensure_trailing_slash(char **input)
       curlx_dyn_init(&dyn, len + 2);
 
       if(curlx_dyn_addn(&dyn, *input, len)) {
-        curlx_safefree(*input);
+        tool_safefree(*input);
         return CURLE_OUT_OF_MEMORY;
       }
 
-      curlx_safefree(*input);
+      tool_safefree(*input);
 
       if(curlx_dyn_addn(&dyn, "/", 1))
         return CURLE_OUT_OF_MEMORY;
@@ -90,7 +90,7 @@ static char *ipfs_gateway(void)
     goto fail;
 
   gateway_file = fopen(gateway_composed_file_path, FOPEN_READTEXT);
-  curlx_safefree(gateway_composed_file_path);
+  tool_safefree(gateway_composed_file_path);
 
   if(gateway_file) {
     int c;
@@ -116,15 +116,15 @@ static char *ipfs_gateway(void)
     if(!gateway)
       goto fail;
 
-    curlx_safefree(ipfs_path);
+    tool_safefree(ipfs_path);
 
     return gateway;
   }
 fail:
   if(gateway_file)
     fclose(gateway_file);
-  curlx_safefree(gateway);
-  curlx_safefree(ipfs_path);
+  tool_safefree(gateway);
+  tool_safefree(ipfs_path);
   return NULL;
 }
 
@@ -245,7 +245,7 @@ CURLcode ipfs_url_rewrite(CURLU *uh, const char *protocol, char **url,
   }
 
   /* Free whatever it has now, rewriting is next */
-  curlx_safefree(*url);
+  tool_safefree(*url);
 
   if(curl_url_get(uh, CURLUPART_URL, &cloneurl, CURLU_URLENCODE)) {
     goto clean;

diff --git a/src/tool_main.c b/src/tool_main.c
index 1b0493c33d42919b85be37fca359027d59acd03a..b78fe28b50fb00fb7f1e6b1d098ba5dd9b78bd0f 100644 (file)
--- a/src/tool_main.c
+++ b/src/tool_main.c
@@ -197,13 +197,13 @@ static CURLcode main_init(struct GlobalConfig *config)
 
 static void free_globalconfig(struct GlobalConfig *config)
 {
-  curlx_safefree(config->trace_dump);
+  tool_safefree(config->trace_dump);
 
   if(config->trace_fopened && config->trace_stream)
     fclose(config->trace_stream);
   config->trace_stream = NULL;
 
-  curlx_safefree(config->libcurl);
+  tool_safefree(config->libcurl);
 }
 
 /*

diff --git a/src/tool_operate.c b/src/tool_operate.c
index 56b93b7592665c8b6b6fbd500d7dbd1f39ad5057..473ed891b4b658630c96db48a0a077a932b93f56 100644 (file)
--- a/src/tool_operate.c
+++ b/src/tool_operate.c
@@ -424,8 +424,8 @@ void single_transfer_cleanup(struct OperationConfig *config)
     struct State *state = &config->state;
     /* Free list of remaining URLs */
     glob_cleanup(&state->urls);
-    curlx_safefree(state->outfiles);
-    curlx_safefree(state->uploadfile);
+    tool_safefree(state->outfiles);
+    tool_safefree(state->uploadfile);
     /* Free list of globbed upload files */
     glob_cleanup(&state->inglob);
   }
@@ -743,13 +743,13 @@ skip:
     fclose(per->heads.stream);
 
   if(per->heads.alloc_filename)
-    curlx_safefree(per->heads.filename);
+    tool_safefree(per->heads.filename);
 
   if(per->etag_save.fopened && per->etag_save.stream)
     fclose(per->etag_save.stream);
 
   if(per->etag_save.alloc_filename)
-    curlx_safefree(per->etag_save.filename);
+    tool_safefree(per->etag_save.filename);
 
   curl_easy_cleanup(per->curl);
   if(outs->alloc_filename)
@@ -1928,7 +1928,7 @@ static CURLcode single_transfer(struct GlobalConfig *global,
         if((PARAM_OK == file2string(&etag_from_file, file)) &&
            etag_from_file) {
           header = aprintf("If-None-Match: %s", etag_from_file);
-          curlx_safefree(etag_from_file);
+          tool_safefree(etag_from_file);
         }
         else
           header = aprintf("If-None-Match: \"\"");
@@ -1944,7 +1944,7 @@ static CURLcode single_transfer(struct GlobalConfig *global,
 
         /* add Etag from file to list of custom headers */
         pe = add2list(&config->headers, header);
-        curlx_safefree(header);
+        tool_safefree(header);
 
         if(file)
           fclose(file);
@@ -1967,7 +1967,7 @@ static CURLcode single_transfer(struct GlobalConfig *global,
           if(!newfile) {
             warnf(global, "Failed creating file for saving etags: \"%s\". "
                   "Skip this transfer", config->etag_save_file);
-            curlx_safefree(state->outfiles);
+            tool_safefree(state->outfiles);
             glob_cleanup(&state->urls);
             return CURLE_OK;
           }
@@ -2004,7 +2004,7 @@ static CURLcode single_transfer(struct GlobalConfig *global,
           break;
         }
         if(SetHTTPrequest(config, TOOL_HTTPREQ_PUT, &config->httpreq)) {
-          curlx_safefree(per->uploadfile);
+          tool_safefree(per->uploadfile);
           curl_easy_cleanup(curl);
           result = CURLE_FAILED_INIT;
           break;
@@ -2127,7 +2127,7 @@ static CURLcode single_transfer(struct GlobalConfig *global,
           /* fill '#1' ... '#9' terms from URL pattern */
           char *storefile = per->outfile;
           result = glob_match_url(&per->outfile, storefile, state->urls);
-          curlx_safefree(storefile);
+          tool_safefree(storefile);
           if(result) {
             /* bad globbing */
             warnf(global, "bad output glob");
@@ -2323,7 +2323,7 @@ static CURLcode single_transfer(struct GlobalConfig *global,
         state->urlnum = 0; /* forced reglob of URLs */
         glob_cleanup(&state->urls);
         state->up++;
-        curlx_safefree(state->uploadfile); /* clear it to get the next */
+        tool_safefree(state->uploadfile); /* clear it to get the next */
       }
     }
     else {
@@ -2333,8 +2333,8 @@ static CURLcode single_transfer(struct GlobalConfig *global,
       glob_cleanup(&state->urls);
       state->urlnum = 0;
 
-      curlx_safefree(state->outfiles);
-      curlx_safefree(state->uploadfile);
+      tool_safefree(state->outfiles);
+      tool_safefree(state->uploadfile);
       /* Free list of globbed upload files */
       glob_cleanup(&state->inglob);
       state->up = 0;
@@ -2342,7 +2342,7 @@ static CURLcode single_transfer(struct GlobalConfig *global,
     }
     break;
   }
-  curlx_safefree(state->outfiles);
+  tool_safefree(state->outfiles);
 fail:
   if(!*added || result) {
     *added = FALSE;

diff --git a/src/tool_operhlp.c b/src/tool_operhlp.c
index 7019b514cb20cf01c551a3dca467675256c34f2c..6a6cf202c8ba3901accab12b9d51c872fe0f6b79 100644 (file)
--- a/src/tool_operhlp.c
+++ b/src/tool_operhlp.c
@@ -39,10 +39,10 @@ void clean_getout(struct OperationConfig *config)
 
     while(node) {
       next = node->next;
-      curlx_safefree(node->url);
-      curlx_safefree(node->outfile);
-      curlx_safefree(node->infile);
-      curlx_safefree(node);
+      tool_safefree(node->url);
+      tool_safefree(node->outfile);
+      tool_safefree(node->infile);
+      tool_safefree(node);
       node = next;
     }
     config->url_list = NULL;
@@ -224,7 +224,7 @@ CURLcode get_url_file_name(struct GlobalConfig *global,
       {
         char *sanitized;
         SANITIZEcode sc = sanitize_file_name(&sanitized, *filename, 0);
-        curlx_safefree(*filename);
+        tool_safefree(*filename);
         if(sc) {
           if(sc == SANITIZE_ERR_OUT_OF_MEMORY)
             return CURLE_OUT_OF_MEMORY;

diff --git a/src/tool_parsecfg.c b/src/tool_parsecfg.c
index 05c23a646fc27da7a0adcd468f55974b90c04885..9ce734be6e75e6e0d7b3aa69424e8da43bf09978 100644 (file)
--- a/src/tool_parsecfg.c
+++ b/src/tool_parsecfg.c
@@ -221,7 +221,7 @@ int parseconfig(const char *filename, struct GlobalConfig *global)
       }
 
       if(alloced_param)
-        curlx_safefree(param);
+        tool_safefree(param);
     }
     curlx_dyn_free(&buf);
     if(file != stdin)

diff --git a/src/tool_urlglob.c b/src/tool_urlglob.c
index 22d86353585a0ab4d1251b8b924544da054ecab0..c8fa301b9943150d82377e9c68d38e8f78d02578 100644 (file)
--- a/src/tool_urlglob.c
+++ b/src/tool_urlglob.c
@@ -447,7 +447,7 @@ CURLcode glob_url(struct URLGlob **glob, char *url, curl_off_t *urlnum,
 
   glob_expand = calloc(1, sizeof(struct URLGlob));
   if(!glob_expand) {
-    curlx_safefree(glob_buffer);
+    tool_safefree(glob_buffer);
     return CURLE_OUT_OF_MEMORY;
   }
   glob_expand->urllen = strlen(url);
@@ -497,13 +497,13 @@ void glob_cleanup(struct URLGlob **globp)
       for(elem = glob->pattern[i].content.Set.size - 1;
           elem >= 0;
           --elem) {
-        curlx_safefree(glob->pattern[i].content.Set.elements[elem]);
+        tool_safefree(glob->pattern[i].content.Set.elements[elem]);
       }
-      curlx_safefree(glob->pattern[i].content.Set.elements);
+      tool_safefree(glob->pattern[i].content.Set.elements);
     }
   }
-  curlx_safefree(glob->glob_buffer);
-  curlx_safefree(glob);
+  tool_safefree(glob->glob_buffer);
+  tool_safefree(glob);
   *globp = NULL;
 }