curl-to-php js by @Codewith.it - Codewith.it

#main, .loader-cont { display: none; } JavaScript disabilitato.
Non puoi usare Codewith.it senza JavaScript.

References

<tfoot>Definisce il footer o sezione inferiore di una tabella.
maxImposta il valore numerico o temporale massimo per un elemento input
<hr>Inserisce una linea orizzontale
<object>Incorpora risorse varie nella pagina web.
nameDetermina il nome degli elementi HTML o fornisce dati su un attributo associato.
downloadConsente di scaricare file al click di collegamento ipertestuale.

Users

Log in to search for users

Explore

Find inspiration

ESERCIZI RIEPILOGATIVI - 1

Estratti di mitologie greche

5/10/24 es. 8 - conta alfabeto

Download 7-Zip for PC Windows

HTML

CSS

JS

terminal console

feedback

add_box New

cookie Policy

Privacy information and cookies

We use cookies or technologies for technical purposes and, with your consent, also for other purposes as specified in the cookie policy. Refusal of consent may make some functions unavailable. Read more about the privacy policy

Click on “Agree” to confirm.

/*
	curl-to-PHP converter
	codice originale https://github.com/mholt/curl-to-go
	reinterpretato byte-post.com - codewith.it da Simone Bernardo.
   -  https://www.byte-post.com/curl-to-php-convertitore
   -  https://codewith.it/p/2301yaxGHtzi
*/
function curlToPHP(curl) {
  var err = 'if (curl_errno($ch)) {\n    echo \'Errore:\' . curl_error($ch);\n}\n';
  var endCurl = 'curl_close($ch);\n';
  var promo = "// Generato da BytePost cURL to PHP (byte-post.com)";
  var start = "$ch = curl_init();\n\n";
  var result = '$result = curl_exec($ch);';
  var boolOptions = ['#', 'progress-bar', '-', 'next', '0', 'http1.0', 'http1.1', 'http2',
                     'no-npn', 'no-alpn', '1', 'tlsv1', '2', 'sslv2', '3', 'sslv3', '4', 'ipv4', '6', 'ipv6',
                     'a', 'append', 'anyauth', 'B', 'use-ascii', 'basic', 'compressed', 'create-dirs',
                     'crlf', 'digest', 'disable-eprt', 'disable-epsv', 'environment', 'cert-status',
                     'false-start', 'f', 'fail', 'ftp-create-dirs', 'ftp-pasv', 'ftp-skip-pasv-ip',
                     'ftp-pret', 'ftp-ssl-ccc', 'ftp-ssl-control', 'g', 'globoff', 'G', 'get',
                     'ignore-content-length', 'i', 'include', 'I', 'head', 'j', 'junk-session-cookies',
                     'J', 'remote-header-name', 'k', 'insecure', 'l', 'list-only', 'L', 'location',
                     'location-trusted', 'metalink', 'n', 'netrc', 'N', 'no-buffer', 'netrc-file',
                     'netrc-optional', 'negotiate', 'no-keepalive', 'no-sessionid', 'ntlm', 'O',
                     'remote-name', 'oauth2-bearer', 'p', 'proxy-tunnel', 'path-as-is', 'post301', 'post302',
                     'post303', 'proxy-anyauth', 'proxy-basic', 'proxy-digest', 'proxy-negotiate',
                     'proxy-ntlm', 'q', 'raw', 'remote-name-all', 's', 'silent', 'sasl-ir', 'S', 'show-error',
                     'ssl', 'ssl-reqd', 'ssl-allow-beast', 'ssl-no-revoke', 'socks5-gssapi-nec', 'tcp-nodelay',
                     'tlsv1.0', 'tlsv1.1', 'tlsv1.2', 'tr-encoding', 'trace-time', 'v', 'verbose', 'xattr',
                     'h', 'help', 'M', 'manual', 'V', 'version'];
  if (!curl.trim())
    return;
  var cmd = parseCommand(curl, {
    boolFlags: boolOptions }
                        );
  if (cmd._[0] != "curl")
    throw "Non è un comando curl";
  var req = extractRelevantPieces(cmd);
  var code = promo+"\n"+start;
  code += 'curl_setopt($ch, CURLOPT_URL, '+phpExpandEnv(req.url)+');\ncurl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);\n';
  if (req.headers.length == 0 && !req.data.ascii && !req.data.files && !req.data.multipart && !req.basicauth && !req.compressed) {
    return code+renderSimple(req.method);
  }
  else {
    return code+renderComplex(req);
  }
  function renderSimple(method) {
    var php = "";
    if (method == "POST")
      php = 'curl_setopt($ch, CURLOPT_POST, 1);\n';
    else if (method == "HEAD")
      php = 'curl_setopt($ch, CURLOPT_CUSTOMREQUEST, \'HEAD\');\ncurl_setopt($ch, CURLOPT_NOBODY, true);\n';
    else if (method != "GET")
      php = 'curl_setopt($ch, CURLOPT_CUSTOMREQUEST, '+phpExpandEnv(method)+');\n';
    return php + '\n' + result + '\n' + err + endCurl;
  }
  function renderComplex(req) {
    var php = "";
    var headers = {
    };
    for (var i = 0; i < req.headers.length; i++) {
      var split = req.headers[i].indexOf(":");
      if (split == -1) continue;
      var name = req.headers[i].substr(0, split).trim();
      var value = req.headers[i].substr(split+1).trim();
      headers[toTitleCase(name)] = value;
    }
    if (req.method == "POST")
      php += 'curl_setopt($ch, CURLOPT_POST, 1);\n';
    else if (req.method == "HEAD")
      php += 'curl_setopt($ch, CURLOPT_CUSTOMREQUEST, \'HEAD\');\ncurl_setopt($ch, CURLOPT_NOBODY, true);\n';
    else
      php += 'curl_setopt($ch, CURLOPT_CUSTOMREQUEST, '+phpExpandEnv(req.method)+');\n\n';
    var defaultPayloadVar = "$body";
    if (req.data.ascii || req.data.files || req.data.multipart) {
      var ioReaders = [];
      // if there's text data...
      if (req.data.ascii) {
        var stringBody = function() {
          ioReaders.push(JSON.stringify(req.data.ascii));
        }
        stringBody();
      }
      if (req.data.files && req.data.files.length > 0) {
        var varName = "file";
        for (var i = 0; i < req.data.files.length; i++) {
          var thisVarName = (req.data.files.length > 1 ? varName+(i+1) : varName);
          ioReaders.push('\''+thisVarName+'\' => \'@\' .realpath('+phpExpandEnv(req.data.files[i])+')');
        }
      }
      // if multipart data...
      if (req.data.multipart && req.data.multipart.length > 0) {
        for (var i = 0; i < req.data.multipart.length; i++) {
          var arg = req.data.multipart[i];
          var argSplit = arg.indexOf("=");
          if (argSplit > -1) {
            var argValue = arg.substr(argSplit+1);
            var argName = arg.substr(0, argSplit);
            if(argValue.startsWith("@")){
              //if it a file
              ioReaders.push('\''+argName+'\' => \'@\' .realpath('+phpExpandEnv(argValue.substr(1))+')');
            }
            else{
              ioReaders.push('\''+argName+'\' => '+ phpExpandEnv(argValue));
            }
          }
        }
      }
      if (ioReaders.length == 1 && typeof varName == 'undefined') {
        //If variable have code ".. -d attributes='{...", delete quotes.
        ioReaders[0] = ioReaders[0].replace(/\=[\'\"]\{([^$]+)\}[\'\"]/, '={$1}');
        php += 'curl_setopt($ch, CURLOPT_POSTFIELDS, '+ioReaders[0]+');\n';
      }
      else if (ioReaders.length > 0) {
        php += '$post = array(\n    ';
        php += ioReaders.join(",\n    ");
        php += '\n);\n';
        php += 'curl_setopt($ch, CURLOPT_POSTFIELDS, $post);\n';
      }
    }
    // set basic auth
    if (req.basicauth) {
      php += 'curl_setopt($ch, CURLOPT_USERPWD, '+phpExpandEnv(req.basicauth.user)+' . \':\' . '+phpExpandEnv(req.basicauth.pass)+');\n';
    }
    // set compressed
    if (req.compressed) {
      php += 'curl_setopt($ch, CURLOPT_ENCODING, \'gzip, deflate\');\n';
    }
    // set headers
    for (var name in headers) {
      if (typeof phpHeader == 'undefined') {
        phpHeader = '\n$headers = array();\n';
      }
      phpHeader += '$headers[] = '+phpExpandEnv(name).slice(0,-1)+': '+phpExpandEnv(headers[name]).slice(1)+';\n';
    }
    if (typeof phpHeader != 'undefined') {
      php += phpHeader + 'curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);\n';
    }
    delete phpHeader;
    // complete request
    php += '\n' + result + '\n' + err + endCurl
    return php;
  }
  function extractRelevantPieces(cmd) {
    var relevant = {
      url: "",
      method: "",
      headers: [],
      data: {
      }
    };
    // prefer --url over unnamed parameter, if it exists; keep first one only
    if (cmd.url && cmd.url.length > 0)
      relevant.url = cmd.url[0]
    else if (cmd._.length > 1)
      relevant.url = cmd._[1];
    // position 1 because index 0 is the curl command itself
    // gather the headers together
    if (cmd.H)
      relevant.headers = relevant.headers.concat(cmd.H);
    if (cmd.header)
      relevant.headers = relevant.headers.concat(cmd.header);
    // set method to HEAD?
    if (cmd.I || cmd.head)
      relevant.method = "HEAD";
    if (cmd.request && cmd.request.length > 0)
      relevant.method = cmd.request[cmd.request.length-1].toUpperCase();
    else if (cmd.X && cmd.X.length > 0)
      relevant.method = cmd.X[cmd.X.length-1].toUpperCase();
    var dataAscii = [];
    var dataMultipart = [];
    var dataFiles = [];
    var loadData = function(d, multipart) {
      if (!relevant.method)
        relevant.method = "POST";
      var hasContentType = false;
      for (var i = 0; i < relevant.headers.length; i++) {
        if (toTitleCase(relevant.headers[i]).indexOf("Content-Type") == 0) {
          hasContentType = true;
          break;
        }
      }
      if (!hasContentType && !multipart)
        relevant.headers.push("Content-Type: application/x-www-form-urlencoded");
      for (var i = 0; i < d.length; i++)
      {
        if (multipart)
          dataMultipart.push(d[i]);
        else if (d[i].length > 0 && d[i][0] == "@")
          dataFiles.push(d[i].substr(1));
        else
          dataAscii.push(d[i]);
      }
    };
    if (cmd.d)
      loadData(cmd.d);
    if (cmd.data)
      loadData(cmd.data);
    if (cmd['data-binary'])
      loadData(cmd['data-binary']);
    if (cmd.F)
      loadData(cmd.F, true);
    if (cmd.form)
      loadData(cmd.form, true);
    if (dataAscii.length > 0)
      relevant.data.ascii = dataAscii.join("&");
    if(dataMultipart.length > 0)
      relevant.data.multipart = dataMultipart;
    if (dataFiles.length > 0)
      relevant.data.files = dataFiles;
    if (cmd.compressed)
      relevant.compressed = true;
    // between -u and --user, choose the long form...
    var basicAuthString = "";
    if (cmd.user && cmd.user.length > 0)
      basicAuthString = cmd.user[cmd.user.length-1];
    else if (cmd.u && cmd.u.length > 0)
      basicAuthString = cmd.u[cmd.u.length-1];
    var basicAuthSplit = basicAuthString.indexOf(":");
    if (basicAuthSplit > -1) {
      relevant.basicauth = {
        user: basicAuthString.substr(0, basicAuthSplit),
        pass: basicAuthString.substr(basicAuthSplit+1)
      };
    }
    else {
      relevant.basicAuth = {
        user: basicAuthString, pass: "<PASSWORD>" };
    }
    // default to GET if nothing else specified
    if (!relevant.method)
      relevant.method = "GET";
    return relevant;
  }
  function toTitleCase(str) {
    return str.replace(/\w*/g, function(txt) {
      return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();
    }
                      );
  }
  function phpExpandEnv(s) {
    var pos = s.indexOf("$");
    if (pos > -1)
    {
      if (pos > 0 && s[pos-1] == '\\') {
        // The $ is escaped, so strip the escaping backslash
        s = s.substr(0, pos-1) + s.substr(pos);
      }
      else {
        // $ is not escaped, so treat it as an env variable
        return '$_ENV["'+phpEsc(s).replace(/\$/g, '')+'"]';
      }
    }
    return '\''+phpEsc(s)+'\'';
  }
  function phpEsc(s) {
    return s.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
  }
}
function parseCommand(input, options) {
  if (typeof options === 'undefined') {
    options = {
    };
  }
  var result = {
    _: []}
  , // what we return
      cursor = 0,       // iterator position
      token = "";
  // current token (word or quoted string) being built
  // trim leading $ or # that may have been left in
  input = input.trim();
  if (input.length > 2 && (input[0] == '$' || input[0] == '#') && whitespace(input[1]))
    input = input.substr(1).trim();
  for (cursor = 0; cursor < input.length; cursor++) {
    skipWhitespace();
    if (input[cursor] == "-") {
      flagSet();
    }
    else {
      unflagged();
    }
  }
  return result;
  function flagSet() {
    // long flag form?
    if (cursor < input.length-1 && input[cursor+1] == "-") {
      return longFlag();
    }
    // if not, parse short flag form
    cursor++;
    // skip leading dash
    while (cursor < input.length && !whitespace(input[cursor]))
    {
      var flagName = input[cursor];
      if (typeof result[flagName] == 'undefined') {
        result[flagName] = [];
      }
      cursor++;
      // skip the flag name
      if (boolFlag(flagName))
        result[flagName] = true;
      else if (Array.isArray(result[flagName]))
        result[flagName].push(nextString());
    }
  }
  function longFlag() {
    cursor += 2;
    // skip leading dashes
    var flagName = nextString("=");
    if (boolFlag(flagName))
      result[flagName] = true;
    else {
      if (typeof result[flagName] == 'undefined') {
        result[flagName] = [];
      }
      if (Array.isArray(result[flagName])) {
        result[flagName].push(nextString());
      }
    }
  }
  function unflagged() {
    result._.push(nextString());
  }
  // boolFlag returns whether a flag is known to be boolean type
  function boolFlag(flag) {
    if (Array.isArray(options.boolFlags)) {
      for (var i = 0; i < options.boolFlags.length; i++) {
        if (options.boolFlags[i] == flag)
          return true;
      }
    }
    return false;
  }
  function nextString(endChar) {
    skipWhitespace();
    var str = "";
    var quoted = false,
        quoteCh = "",
        escaped = false;
    if (input[cursor] == '"' || input[cursor] == "'") {
      quoted = true;
      quoteCh = input[cursor];
      cursor++;
    }
    for (; cursor < input.length; cursor++) {
      if (quoted) {
        if (input[cursor] == quoteCh && !escaped) {
          quoted = false;
          continue;
        }
      }
      if (!quoted) {
        if (!escaped) {
          if (whitespace(input[cursor])) {
            return str;
          }
          if (endChar && input[cursor] == endChar) {
            cursor++;
            // skip the endChar
            return str;
          }
        }
      }
      if (!escaped && input[cursor] == "\\") {
        escaped = true;
        // skip the backslash unless the next character is $
        if (!(cursor < input.length-1 && input[cursor+1] == '$'))
          continue;
      }
      str += input[cursor];
      escaped = false;
    }
    return str;
  }
  // skipWhitespace skips whitespace between tokens, taking into account escaped whitespace.
  function skipWhitespace() {
    for (; cursor < input.length; cursor++) {
      while (input[cursor] == "\\" && (cursor < input.length-1 && whitespace(input[cursor+1])))
        cursor++;
      if (!whitespace(input[cursor]))
        break;
    }
  }
  // whitespace returns true if ch is a whitespace character.
  function whitespace(ch) {
    return ch == " " || ch == "\t" || ch == "\n" || ch == "\r";
  }
}