multi interface: fix block when CONNECT_ONLY option is used

        easy->easy_conn->bits.close = FALSE;

        multistate(easy, CURLM_STATE_DONE);

        easy->result = CURLE_OK;

        result = CURLM_OK;

        result = CURLM_CALL_MULTI_PERFORM;

      }

      else {

        /* Perform the protocol's DO action */

test562 test563 test564 test565 test566 test567 test568 test569 test570	\

test571 test572 test573 test574 test575 test576 test578 test579 test580	\

test581 test582 test583 test584 test585 test586 test587 test588 test590 \

test591 test592 test593 test594 test595 test596 \

test591 test592 test593 test594 test595 test596 test597 \

test600 test601 test602 test603 test604	\

test605 test606 test607 test608 test609 test610 test611 test612 test613	\

test614 test615 test616 test617 test618 test619 test620 test621 test622	\

<testcase>

<info>

<keywords>

FTP

CONNECT_ONLY

</keywords>

</info>

# Client-side

<client>

<server>

ftp

</server>

<tool>

lib597

</tool>

 <name>

FTP connect only option

 </name>

<command>

ftp://%HOSTIP:%FTPPORT

</command>

</client>

#

# Verify data after the test has been "shot"

<verify>

<protocol>

USER anonymous

PASS ftp@example.com

PWD

QUIT

</protocol>

</verify>

</testcase>

  lib543 lib544 lib545 lib547 lib548 lib549 lib552 lib553 lib554 lib555	\

  lib556 lib539 lib557 lib560 lib562 lib564 lib565 lib566 lib567 lib568	\

  lib569 lib570 lib571 lib572 lib573 lib582 lib583 lib585 lib586 lib587 \

  lib590 lib591

  lib590 lib591 lib597

chkhostname_SOURCES = chkhostname.c $(top_srcdir)/lib/curl_gethostname.c

chkhostname_LDADD = @CURL_NETWORK_LIBS@

lib590_SOURCES = lib590.c $(SUPPORTFILES)

lib591_SOURCES = lib591.c $(SUPPORTFILES) $(TESTUTIL) $(WARNLESS)

lib597_SOURCES = lib597.c $(SUPPORTFILES) $(TESTUTIL) $(WARNLESS)

/***************************************************************************

 *                                  _   _ ____  _

 *  Project                     ___| | | |  _ \| |

 *                             / __| | | | |_) | |

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

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

 *

 * Copyright (C) 1998 - 2011, 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

 * are also available at http://curl.haxx.se/docs/copyright.html.

 *

 * You may opt to use, copy, modify, merge, publish, distribute and/or sell

 * copies of the Software, and permit persons to whom the Software is

 * furnished to do so, under the terms of the COPYING file.

 *

 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY

 * KIND, either express or implied.

 *

 ***************************************************************************/

#include "test.h"

#include "testutil.h"

#include "warnless.h"

#include "memdebug.h"

#define TEST_HANG_TIMEOUT 5 * 1000

/*

 * Test case for below scenario:

 *   - Connect to an FTP server using CONNECT_ONLY option

 *   - transfer some files with re-using the connection (omitted in test case)

 *   - Disconnect from FTP server with sending QUIT command

 *

 * The test case originated for verifying CONNECT_ONLY option shall not

 * block after protocol connect is done, but it returns the message

 * with function curl_multi_info_read().

 */

enum {

  CONNECT_ONLY_PHASE = 0,

  QUIT_PHASE,

  LAST_PHASE

};

int test(char *URL)

{

  CURL *easy = NULL;

  CURLM *multi = NULL;

  int res = 0;

  int running;

  int msgs_left;

  int phase;

  CURLMsg *msg;

  start_test_timing();

  res_global_init(CURL_GLOBAL_ALL);

  if(res) {

    return res;

  }

  easy_init(easy);

  multi_init(multi);

  for (phase = CONNECT_ONLY_PHASE; phase < LAST_PHASE; ++phase) {

    /* go verbose */

    easy_setopt(easy, CURLOPT_VERBOSE, 1L);

    /* specify target */

    easy_setopt(easy, CURLOPT_URL, URL);

    /* enable 'CONNECT_ONLY' option when in connect phase */

    if (phase == CONNECT_ONLY_PHASE)

      easy_setopt(easy, CURLOPT_CONNECT_ONLY, 1L);

    /* enable 'NOBODY' option to send 'QUIT' command in quit phase */

    if (phase == QUIT_PHASE) {

      easy_setopt(easy, CURLOPT_CONNECT_ONLY, 0L);

      easy_setopt(easy, CURLOPT_NOBODY, 1L);

      easy_setopt(easy, CURLOPT_FORBID_REUSE, 1L);

    }

    multi_add_handle(multi, easy);

    for(;;) {

      struct timeval interval;

      fd_set fdread;

      fd_set fdwrite;

      fd_set fdexcep;

      long timeout = -99;

      int maxfd = -99;

      multi_perform(multi, &running);

      abort_on_test_timeout();

      if(!running)

        break; /* done */

      FD_ZERO(&fdread);

      FD_ZERO(&fdwrite);

      FD_ZERO(&fdexcep);

      multi_fdset(multi, &fdread, &fdwrite, &fdexcep, &maxfd);

      /* At this point, maxfd is guaranteed to be greater or equal than -1. */

      multi_timeout(multi, &timeout);

      /* At this point, timeout is guaranteed to be greater or equal than -1. */

      if(timeout != -1L) {

        interval.tv_sec = timeout/1000;

        interval.tv_usec = (timeout%1000)*1000;

      }

      else {

        interval.tv_sec = TEST_HANG_TIMEOUT/1000+1;

        interval.tv_usec = 0;

      }

      select_test(maxfd+1, &fdread, &fdwrite, &fdexcep, &interval);

      abort_on_test_timeout();

    }

    msg = curl_multi_info_read(multi, &msgs_left);

    if(msg)

      res = msg->data.result;

    multi_remove_handle(multi, easy);

  }

test_cleanup:

  /* undocumented cleanup sequence - type UA */

  curl_multi_cleanup(multi);

  curl_easy_cleanup(easy);

  curl_global_cleanup();

  return res;

}