Based on a patch by Armel Asselin, the FTP code no longer re-issues the TYPE

                                  Changelog

Daniel (19 August 2006)

- Based on a patch by Armel Asselin, the FTP code no longer re-issues the TYPE

  command on subsequent requests on a re-used connection unless it has to.

- Armel Asselin fixed a crash in the FTP code when using SINGLECWD mode and

  files in the root directory.

This release includes the following changes:

 o (FTP) libcurl avoids sending TYPE if the desired type was already set

 o CURLOPT_PREQUOTE works even when CURLOPT_NOBODY is set true

This release includes the following bugfixes:

};

static CURLcode

process_zlib_error(struct SessionHandle *data,

 z_stream *z)

process_zlib_error(struct connectdata *conn, z_stream *z)

{

  struct SessionHandle *data = conn->data;

  if (z->msg)

    failf (data, "Error while processing content unencoding: %s",

           z->msg);

}

static CURLcode

inflate_stream(struct SessionHandle *data,

inflate_stream(struct connectdata *conn,

               struct Curl_transfer_keeper *k)

{

  int allow_restart = 1;

    if (status == Z_OK || status == Z_STREAM_END) {

      allow_restart = 0;

      if(DSIZ - z->avail_out) {

        result = Curl_client_write(data, CLIENTWRITE_BODY, decomp,

        result = Curl_client_write(conn, CLIENTWRITE_BODY, decomp,

                                   DSIZ - z->avail_out);

        /* if !CURLE_OK, clean up, return */

        if (result) {

        if (inflateEnd(z) == Z_OK)

          return exit_zlib(z, &k->zlib_init, result);

        else

          return exit_zlib(z, &k->zlib_init, process_zlib_error(data, z));

          return exit_zlib(z, &k->zlib_init, process_zlib_error(conn, z));

      }

      /* Done with these bytes, exit */

      inflateReset(z);

      if (inflateInit2(z, -MAX_WBITS) != Z_OK) {

        return process_zlib_error(data, z);

        return process_zlib_error(conn, z);

      }

      z->next_in = orig_in;

      z->avail_in = nread;

    }

    else {                      /* Error; exit loop, handle below */

      free(decomp);

      return exit_zlib(z, &k->zlib_init, process_zlib_error(data, z));

      return exit_zlib(z, &k->zlib_init, process_zlib_error(conn, z));

    }

  }

  /* Will never get here */

}

CURLcode

Curl_unencode_deflate_write(struct SessionHandle *data,

Curl_unencode_deflate_write(struct connectdata *conn,

                            struct Curl_transfer_keeper *k,

                            ssize_t nread)

{

    z->next_in = NULL;

    z->avail_in = 0;

    if (inflateInit(z) != Z_OK)

      return process_zlib_error(data, z);

      return process_zlib_error(conn, z);

    k->zlib_init = ZLIB_INIT;

  }

  z->avail_in = (uInt)nread;

  /* Now uncompress the data */

  return inflate_stream(data, k);

  return inflate_stream(conn, k);

}

#ifdef OLD_ZLIB_SUPPORT

#endif

CURLcode

Curl_unencode_gzip_write(struct SessionHandle *data,

Curl_unencode_gzip_write(struct connectdata *conn,

                         struct Curl_transfer_keeper *k,

                         ssize_t nread)

{

    if (strcmp(zlibVersion(), "1.2.0.4") >= 0) {

        /* zlib ver. >= 1.2.0.4 supports transparent gzip decompressing */

        if (inflateInit2(z, MAX_WBITS+32) != Z_OK) {

          return process_zlib_error(data, z);

          return process_zlib_error(conn, z);

        }

        k->zlib_init = ZLIB_INIT_GZIP; /* Transparent gzip decompress state */

    } else {

        /* we must parse the gzip header ourselves */

        if (inflateInit2(z, -MAX_WBITS) != Z_OK) {

          return process_zlib_error(data, z);

          return process_zlib_error(conn, z);

        }

        k->zlib_init = ZLIB_INIT;   /* Initial call state */

    }

     z->next_in = (Bytef *)k->str;

     z->avail_in = (uInt)nread;

     /* Now uncompress the data */

     return inflate_stream(data, k);

     return inflate_stream(conn, k);

  }

#ifndef OLD_ZLIB_SUPPORT

    case GZIP_BAD:

    default:

      return exit_zlib(z, &k->zlib_init, process_zlib_error(data, z));

      return exit_zlib(z, &k->zlib_init, process_zlib_error(conn, z));

    }

  }

    case GZIP_BAD:

    default:

      free(z->next_in);

      return exit_zlib(z, &k->zlib_init, process_zlib_error(data, z));

      return exit_zlib(z, &k->zlib_init, process_zlib_error(conn, z));

    }

  }

  }

  /* We've parsed the header, now uncompress the data */

  return inflate_stream(data, k);

  return inflate_stream(conn, k);

#endif

}

#endif /* HAVE_LIBZ */

 *                            | (__| |_| |  _ <| |___

 *                             \___|\___/|_| \_\_____|

 *

 * Copyright (C) 1998 - 2004, Daniel Stenberg, <daniel@haxx.se>, et al.

 * Copyright (C) 1998 - 2006, Daniel Stenberg, <daniel@haxx.se>, et al.

 *

 * This software is licensed as described in the file COPYING, which

 * you should have received as part of this distribution. The terms

#define ALL_CONTENT_ENCODINGS "identity"

#endif

CURLcode Curl_unencode_deflate_write(struct SessionHandle *data,

CURLcode Curl_unencode_deflate_write(struct connectdata *conn,

                                     struct Curl_transfer_keeper *k,

                                     ssize_t nread);

CURLcode

Curl_unencode_gzip_write(struct SessionHandle *data,

Curl_unencode_gzip_write(struct connectdata *conn,

                         struct Curl_transfer_keeper *k,

                         ssize_t nread);

    CURLcode result;

    snprintf(buf, sizeof(data->state.buffer),

             "Content-Length: %" FORMAT_OFF_T "\r\n", expected_size);

    result = Curl_client_write(data, CLIENTWRITE_BOTH, buf, 0);

    result = Curl_client_write(conn, CLIENTWRITE_BOTH, buf, 0);

    if(result)

      return result;

    result = Curl_client_write(data, CLIENTWRITE_BOTH,

    result = Curl_client_write(conn, CLIENTWRITE_BOTH,

                               (char *)"Accept-ranges: bytes\r\n", 0);

    if(result)

      return result;

               tm->tm_hour,

               tm->tm_min,

               tm->tm_sec);

      result = Curl_client_write(data, CLIENTWRITE_BOTH, buf, 0);

      result = Curl_client_write(conn, CLIENTWRITE_BOTH, buf, 0);

    }

    return result;

  }

    bytecount += nread;

    res = Curl_client_write(data, CLIENTWRITE_BODY, buf, nread);

    res = Curl_client_write(conn, CLIENTWRITE_BODY, buf, nread);

    if(res)

      return res;