9535

pending completion

Build # 9535

Build Type

Pull #3275

travis-ci

Committed by

web-flow

Commit Message

http_negotiate: do not close connection until negotiation is completed

Aim of this PR is to fix the HTTP POST using CURLAUTH_NEGOTIATE.

Pull Request Pull Request #3275: http_negotiate: do not close connection until negotiation is completed

Run Details

21925 of 29265 relevant lines covered (74.92%)

744954.07 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

80.95

/lib/file.c

/***************************************************************************
 *                                  _   _ ____  _
 *  Project                     ___| | | |  _ \| |
 *                             / __| | | | |_) | |
 *                            | (__| |_| |  _ <| |___
 *                             \___|\___/|_| \_\_____|
 *
 * Copyright (C) 1998 - 2018, 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 https://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 "curl_setup.h"

#ifndef CURL_DISABLE_FILE

#ifdef HAVE_NETINET_IN_H
#include <netinet/in.h>
#endif
#ifdef HAVE_NETDB_H
#include <netdb.h>
#endif
#ifdef HAVE_ARPA_INET_H
#include <arpa/inet.h>
#endif
#ifdef HAVE_NET_IF_H
#include <net/if.h>
#endif
#ifdef HAVE_SYS_IOCTL_H
#include <sys/ioctl.h>
#endif

#ifdef HAVE_SYS_PARAM_H
#include <sys/param.h>
#endif

#ifdef HAVE_FCNTL_H
#include <fcntl.h>
#endif

#include "strtoofft.h"
#include "urldata.h"
#include <curl/curl.h>
#include "progress.h"
#include "sendf.h"
#include "escape.h"
#include "file.h"
#include "speedcheck.h"
#include "getinfo.h"
#include "transfer.h"
#include "url.h"
#include "parsedate.h" /* for the week day and month names */
#include "warnless.h"
#include "curl_range.h"
/* The last 3 #include files should be in this order */
#include "curl_printf.h"
#include "curl_memory.h"
#include "memdebug.h"

#if defined(WIN32) || defined(MSDOS) || defined(__EMX__) || \
  defined(__SYMBIAN32__)
#define DOS_FILESYSTEM 1
#endif

#ifdef OPEN_NEEDS_ARG3
#  define open_readonly(p,f) open((p),(f),(0))
#else
#  define open_readonly(p,f) open((p),(f))
#endif

/*
 * Forward declarations.
 */

static CURLcode file_do(struct connectdata *, bool *done);
static CURLcode file_done(struct connectdata *conn,
                          CURLcode status, bool premature);
static CURLcode file_connect(struct connectdata *conn, bool *done);
static CURLcode file_disconnect(struct connectdata *conn,
                                bool dead_connection);
static CURLcode file_setup_connection(struct connectdata *conn);

/*
 * FILE scheme handler.
 */

const struct Curl_handler Curl_handler_file = {
  "FILE",                               /* scheme */
  file_setup_connection,                /* setup_connection */
  file_do,                              /* do_it */
  file_done,                            /* done */
  ZERO_NULL,                            /* do_more */
  file_connect,                         /* connect_it */
  ZERO_NULL,                            /* connecting */
  ZERO_NULL,                            /* doing */
  ZERO_NULL,                            /* proto_getsock */
  ZERO_NULL,                            /* doing_getsock */
  ZERO_NULL,                            /* domore_getsock */
  ZERO_NULL,                            /* perform_getsock */
  file_disconnect,                      /* disconnect */
  ZERO_NULL,                            /* readwrite */
  ZERO_NULL,                            /* connection_check */
  0,                                    /* defport */
  CURLPROTO_FILE,                       /* protocol */
  PROTOPT_NONETWORK | PROTOPT_NOURLQUERY /* flags */
};


static CURLcode file_setup_connection(struct connectdata *conn)
{
  /* allocate the FILE specific struct */
  conn->data->req.protop = calloc(1, sizeof(struct FILEPROTO));
  if(!conn->data->req.protop)
    return CURLE_OUT_OF_MEMORY;

  return CURLE_OK;
}

/*
 * file_connect() gets called from Curl_protocol_connect() to allow us to
 * do protocol-specific actions at connect-time.  We emulate a
 * connect-then-transfer protocol and "connect" to the file here
 */
static CURLcode file_connect(struct connectdata *conn, bool *done)
{
  struct Curl_easy *data = conn->data;
  char *real_path;
  struct FILEPROTO *file = data->req.protop;
  int fd;
#ifdef DOS_FILESYSTEM
  size_t i;
  char *actual_path;
#endif
  size_t real_path_len;

  CURLcode result = Curl_urldecode(data, data->state.up.path, 0, &real_path,
                                   &real_path_len, FALSE);
  if(result)
    return result;

#ifdef DOS_FILESYSTEM
  /* If the first character is a slash, and there's
     something that looks like a drive at the beginning of
     the path, skip the slash.  If we remove the initial
     slash in all cases, paths without drive letters end up
     relative to the current directory which isn't how
     browsers work.

     Some browsers accept | instead of : as the drive letter
     separator, so we do too.

     On other platforms, we need the slash to indicate an
     absolute pathname.  On Windows, absolute paths start
     with a drive letter.
  */
  actual_path = real_path;
  if((actual_path[0] == '/') &&
      actual_path[1] &&
     (actual_path[2] == ':' || actual_path[2] == '|')) {
    actual_path[2] = ':';
    actual_path++;
    real_path_len--;
  }

  /* change path separators from '/' to '\\' for DOS, Windows and OS/2 */
  for(i = 0; i < real_path_len; ++i)
    if(actual_path[i] == '/')
      actual_path[i] = '\\';
    else if(!actual_path[i]) { /* binary zero */
      Curl_safefree(real_path);
      return CURLE_URL_MALFORMAT;
    }

  fd = open_readonly(actual_path, O_RDONLY|O_BINARY);
  file->path = actual_path;
#else
  if(memchr(real_path, 0, real_path_len)) {
    /* binary zeroes indicate foul play */
    Curl_safefree(real_path);
    return CURLE_URL_MALFORMAT;
  }

  fd = open_readonly(real_path, O_RDONLY);
  file->path = real_path;
#endif
  file->freepath = real_path; /* free this when done */

  file->fd = fd;
  if(!data->set.upload && (fd == -1)) {
    failf(data, "Couldn't open file %s", data->state.up.path);
    file_done(conn, CURLE_FILE_COULDNT_READ_FILE, FALSE);
    return CURLE_FILE_COULDNT_READ_FILE;
  }
  *done = TRUE;

  return CURLE_OK;
}

static CURLcode file_done(struct connectdata *conn,
                               CURLcode status, bool premature)
{
  struct FILEPROTO *file = conn->data->req.protop;
  (void)status; /* not used */
  (void)premature; /* not used */

  if(file) {
    Curl_safefree(file->freepath);
    file->path = NULL;
    if(file->fd != -1)
      close(file->fd);
    file->fd = -1;
  }

  return CURLE_OK;
}

static CURLcode file_disconnect(struct connectdata *conn,
                                bool dead_connection)
{
  struct FILEPROTO *file = conn->data->req.protop;
  (void)dead_connection; /* not used */

  if(file) {
    Curl_safefree(file->freepath);
    file->path = NULL;
    if(file->fd != -1)
      close(file->fd);
    file->fd = -1;
  }

  return CURLE_OK;
}

#ifdef DOS_FILESYSTEM
#define DIRSEP '\\'
#else
#define DIRSEP '/'
#endif

static CURLcode file_upload(struct connectdata *conn)
{
  struct FILEPROTO *file = conn->data->req.protop;
  const char *dir = strchr(file->path, DIRSEP);
  int fd;
  int mode;
  CURLcode result = CURLE_OK;
  struct Curl_easy *data = conn->data;
  char *buf = data->state.buffer;
  curl_off_t bytecount = 0;
  struct_stat file_stat;
  const char *buf2;

  /*
   * Since FILE: doesn't do the full init, we need to provide some extra
   * assignments here.
   */
  conn->data->req.upload_fromhere = buf;

  if(!dir)
    return CURLE_FILE_COULDNT_READ_FILE; /* fix: better error code */

  if(!dir[1])
    return CURLE_FILE_COULDNT_READ_FILE; /* fix: better error code */

#ifdef O_BINARY
#define MODE_DEFAULT O_WRONLY|O_CREAT|O_BINARY
#else
#define MODE_DEFAULT O_WRONLY|O_CREAT
#endif

  if(data->state.resume_from)
    mode = MODE_DEFAULT|O_APPEND;
  else
    mode = MODE_DEFAULT|O_TRUNC;

  fd = open(file->path, mode, conn->data->set.new_file_perms);
  if(fd < 0) {
    failf(data, "Can't open %s for writing", file->path);
    return CURLE_WRITE_ERROR;
  }

  if(-1 != data->state.infilesize)
    /* known size of data to "upload" */
    Curl_pgrsSetUploadSize(data, data->state.infilesize);

  /* treat the negative resume offset value as the case of "-" */
  if(data->state.resume_from < 0) {
    if(fstat(fd, &file_stat)) {
      close(fd);
      failf(data, "Can't get the size of %s", file->path);
      return CURLE_WRITE_ERROR;
    }
    data->state.resume_from = (curl_off_t)file_stat.st_size;
  }

  while(!result) {
    size_t nread;
    size_t nwrite;
    size_t readcount;
    result = Curl_fillreadbuffer(conn, data->set.buffer_size, &readcount);
    if(result)
      break;

    if(readcount <= 0)  /* fix questionable compare error. curlvms */
      break;

    nread = readcount;

    /*skip bytes before resume point*/
    if(data->state.resume_from) {
      if((curl_off_t)nread <= data->state.resume_from) {
        data->state.resume_from -= nread;
        nread = 0;
        buf2 = buf;
      }
      else {
        buf2 = buf + data->state.resume_from;
        nread -= (size_t)data->state.resume_from;
        data->state.resume_from = 0;
      }
    }
    else
      buf2 = buf;

    /* write the data to the target */
    nwrite = write(fd, buf2, nread);
    if(nwrite != nread) {
      result = CURLE_SEND_ERROR;
      break;
    }

    bytecount += nread;

    Curl_pgrsSetUploadCounter(data, bytecount);

    if(Curl_pgrsUpdate(conn))
      result = CURLE_ABORTED_BY_CALLBACK;
    else
      result = Curl_speedcheck(data, Curl_now());
  }
  if(!result && Curl_pgrsUpdate(conn))
    result = CURLE_ABORTED_BY_CALLBACK;

  close(fd);

  return result;
}

/*
 * file_do() is the protocol-specific function for the do-phase, separated
 * from the connect-phase above. Other protocols merely setup the transfer in
 * the do-phase, to have it done in the main transfer loop but since some
 * platforms we support don't allow select()ing etc on file handles (as
 * opposed to sockets) we instead perform the whole do-operation in this
 * function.
 */
static CURLcode file_do(struct connectdata *conn, bool *done)
{
  /* This implementation ignores the host name in conformance with
     RFC 1738. Only local files (reachable via the standard file system)
     are supported. This means that files on remotely mounted directories
     (via NFS, Samba, NT sharing) can be accessed through a file:// URL
  */
  CURLcode result = CURLE_OK;
  struct_stat statbuf; /* struct_stat instead of struct stat just to allow the
                          Windows version to have a different struct without
                          having to redefine the simple word 'stat' */
  curl_off_t expected_size = 0;
  bool size_known;
  bool fstated = FALSE;
  struct Curl_easy *data = conn->data;
  char *buf = data->state.buffer;
  curl_off_t bytecount = 0;
  int fd;
  struct FILEPROTO *file;

  *done = TRUE; /* unconditionally */

  Curl_pgrsStartNow(data);

  if(data->set.upload)
    return file_upload(conn);

  file = conn->data->req.protop;

  /* get the fd from the connection phase */
  fd = file->fd;

  /* VMS: This only works reliable for STREAMLF files */
  if(-1 != fstat(fd, &statbuf)) {
    /* we could stat it, then read out the size */
    expected_size = statbuf.st_size;
    /* and store the modification time */
    data->info.filetime = statbuf.st_mtime;
    fstated = TRUE;
  }

  if(fstated && !data->state.range && data->set.timecondition) {
    if(!Curl_meets_timecondition(data, data->info.filetime)) {
      *done = TRUE;
      return CURLE_OK;
    }
  }

  if(fstated) {
    time_t filetime;
    struct tm buffer;
    const struct tm *tm = &buffer;
    char header[80];
    msnprintf(header, sizeof(header),
              "Content-Length: %" CURL_FORMAT_CURL_OFF_T "\r\n",
              expected_size);
    result = Curl_client_write(conn, CLIENTWRITE_HEADER, header, 0);
    if(result)
      return result;

    result = Curl_client_write(conn, CLIENTWRITE_HEADER,
                               (char *)"Accept-ranges: bytes\r\n", 0);
    if(result)
      return result;

    filetime = (time_t)statbuf.st_mtime;
    result = Curl_gmtime(filetime, &buffer);
    if(result)
      return result;

    /* format: "Tue, 15 Nov 1994 12:45:26 GMT" */
    msnprintf(header, sizeof(header),
              "Last-Modified: %s, %02d %s %4d %02d:%02d:%02d GMT\r\n%s",
              Curl_wkday[tm->tm_wday?tm->tm_wday-1:6],
              tm->tm_mday,
              Curl_month[tm->tm_mon],
              tm->tm_year + 1900,
              tm->tm_hour,
              tm->tm_min,
              tm->tm_sec,
              data->set.opt_no_body ? "": "\r\n");
    result = Curl_client_write(conn, CLIENTWRITE_HEADER, header, 0);
    if(result)
      return result;
    /* set the file size to make it available post transfer */
    Curl_pgrsSetDownloadSize(data, expected_size);
    if(data->set.opt_no_body)
      return result;
  }

  /* Check whether file range has been specified */
  result = Curl_range(conn);
  if(result)
    return result;

  /* Adjust the start offset in case we want to get the N last bytes
   * of the stream if the filesize could be determined */
  if(data->state.resume_from < 0) {
    if(!fstated) {
      failf(data, "Can't get the size of file.");
      return CURLE_READ_ERROR;
    }
    data->state.resume_from += (curl_off_t)statbuf.st_size;
  }

  if(data->state.resume_from <= expected_size)
    expected_size -= data->state.resume_from;
  else {
    failf(data, "failed to resume file:// transfer");
    return CURLE_BAD_DOWNLOAD_RESUME;
  }

  /* A high water mark has been specified so we obey... */
  if(data->req.maxdownload > 0)
    expected_size = data->req.maxdownload;

  if(!fstated || (expected_size == 0))
    size_known = FALSE;
  else
    size_known = TRUE;

  /* The following is a shortcut implementation of file reading
     this is both more efficient than the former call to download() and
     it avoids problems with select() and recv() on file descriptors
     in Winsock */
  if(fstated)
    Curl_pgrsSetDownloadSize(data, expected_size);

  if(data->state.resume_from) {
    if(data->state.resume_from !=
       lseek(fd, data->state.resume_from, SEEK_SET))
      return CURLE_BAD_DOWNLOAD_RESUME;
  }

  Curl_pgrsTime(data, TIMER_STARTTRANSFER);

  while(!result) {
    ssize_t nread;
    /* Don't fill a whole buffer if we want less than all data */
    size_t bytestoread;

    if(size_known) {
      bytestoread = (expected_size < data->set.buffer_size) ?
        curlx_sotouz(expected_size) : (size_t)data->set.buffer_size;
    }
    else
      bytestoread = data->set.buffer_size-1;

    nread = read(fd, buf, bytestoread);

    if(nread > 0)
      buf[nread] = 0;

    if(nread <= 0 || (size_known && (expected_size == 0)))
      break;

    bytecount += nread;
    if(size_known)
      expected_size -= nread;

    result = Curl_client_write(conn, CLIENTWRITE_BODY, buf, nread);
    if(result)
      return result;

    Curl_pgrsSetDownloadCounter(data, bytecount);

    if(Curl_pgrsUpdate(conn))
      result = CURLE_ABORTED_BY_CALLBACK;
    else
      result = Curl_speedcheck(data, Curl_now());
  }
  if(Curl_pgrsUpdate(conn))
    result = CURLE_ABORTED_BY_CALLBACK;

  return result;
}

#endif

1	/***************************************************************************
2	* _ _ ____ _
3	* Project ___\| \| \| \| _ \\| \|
4	* / __\| \| \| \| \|_) \| \|
5	* \| (__\| \|_\| \| _ <\| \|___
6	* \___\|\___/\|_\| \_\_____\|
7	*
8	* Copyright (C) 1998 - 2018, Daniel Stenberg, <daniel@haxx.se>, et al.
9	*
10	* This software is licensed as described in the file COPYING, which
11	* you should have received as part of this distribution. The terms
12	* are also available at https://curl.haxx.se/docs/copyright.html.
13	*
14	* You may opt to use, copy, modify, merge, publish, distribute and/or sell
15	* copies of the Software, and permit persons to whom the Software is
16	* furnished to do so, under the terms of the COPYING file.
17	*
18	* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
19	* KIND, either express or implied.
20	*
21	***************************************************************************/
22
23	#include "curl_setup.h"
24
25	#ifndef CURL_DISABLE_FILE
26
27	#ifdef HAVE_NETINET_IN_H
28	#include <netinet/in.h>
29	#endif
30	#ifdef HAVE_NETDB_H
31	#include <netdb.h>
32	#endif
33	#ifdef HAVE_ARPA_INET_H
34	#include <arpa/inet.h>
35	#endif
36	#ifdef HAVE_NET_IF_H
37	#include <net/if.h>
38	#endif
39	#ifdef HAVE_SYS_IOCTL_H
40	#include <sys/ioctl.h>
41	#endif
42
43	#ifdef HAVE_SYS_PARAM_H
44	#include <sys/param.h>
45	#endif
46
47	#ifdef HAVE_FCNTL_H
48	#include <fcntl.h>
49	#endif
50
51	#include "strtoofft.h"
52	#include "urldata.h"
53	#include <curl/curl.h>
54	#include "progress.h"
55	#include "sendf.h"
56	#include "escape.h"
57	#include "file.h"
58	#include "speedcheck.h"
59	#include "getinfo.h"
60	#include "transfer.h"
61	#include "url.h"
62	#include "parsedate.h" /* for the week day and month names */
63	#include "warnless.h"
64	#include "curl_range.h"
65	/* The last 3 #include files should be in this order */
66	#include "curl_printf.h"
67	#include "curl_memory.h"
68	#include "memdebug.h"
69
70	#if defined(WIN32) \|\| defined(MSDOS) \|\| defined(__EMX__) \|\| \
71	defined(__SYMBIAN32__)
72	#define DOS_FILESYSTEM 1
73	#endif
74
75	#ifdef OPEN_NEEDS_ARG3
76	# define open_readonly(p,f) open((p),(f),(0))
77	#else
78	# define open_readonly(p,f) open((p),(f))
79	#endif
80
81	/*
82	* Forward declarations.
83	*/
84
85	static CURLcode file_do(struct connectdata , bool done);
86	static CURLcode file_done(struct connectdata *conn,
87	CURLcode status, bool premature);
88	static CURLcode file_connect(struct connectdata conn, bool done);
89	static CURLcode file_disconnect(struct connectdata *conn,
90	bool dead_connection);
91	static CURLcode file_setup_connection(struct connectdata *conn);
92
93	/*
94	* FILE scheme handler.
95	*/
96
97	const struct Curl_handler Curl_handler_file = {
98	"FILE", /* scheme */
99	file_setup_connection, /* setup_connection */
100	file_do, /* do_it */
101	file_done, /* done */
102	ZERO_NULL, /* do_more */
103	file_connect, /* connect_it */
104	ZERO_NULL, /* connecting */
105	ZERO_NULL, /* doing */
106	ZERO_NULL, /* proto_getsock */
107	ZERO_NULL, /* doing_getsock */
108	ZERO_NULL, /* domore_getsock */
109	ZERO_NULL, /* perform_getsock */
110	file_disconnect, /* disconnect */
111	ZERO_NULL, /* readwrite */
112	ZERO_NULL, /* connection_check */
113	0, /* defport */
114	CURLPROTO_FILE, /* protocol */
115	PROTOPT_NONETWORK \| PROTOPT_NOURLQUERY /* flags */
116	};
117
118
119	static CURLcode file_setup_connection(struct connectdata *conn)	127✔
120	{
121	/* allocate the FILE specific struct */
122	conn->data->req.protop = calloc(1, sizeof(struct FILEPROTO));	127✔
123	if(!conn->data->req.protop)	127✔
124	return CURLE_OUT_OF_MEMORY;	6✔
125
126	return CURLE_OK;	121✔
127	}
128
129	/*
130	* file_connect() gets called from Curl_protocol_connect() to allow us to
131	* do protocol-specific actions at connect-time. We emulate a
132	* connect-then-transfer protocol and "connect" to the file here
133	*/
134	static CURLcode file_connect(struct connectdata conn, bool done)	121✔
135	{
136	struct Curl_easy *data = conn->data;	121✔
137	char *real_path;
138	struct FILEPROTO *file = data->req.protop;	121✔
139	int fd;
140	#ifdef DOS_FILESYSTEM
141	size_t i;
142	char *actual_path;
143	#endif
144	size_t real_path_len;
145
146	CURLcode result = Curl_urldecode(data, data->state.up.path, 0, &real_path,	121✔
147	&real_path_len, FALSE);
148	if(result)	121✔
149	return result;	6✔
150
151	#ifdef DOS_FILESYSTEM
152	/* If the first character is a slash, and there's
153	something that looks like a drive at the beginning of
154	the path, skip the slash. If we remove the initial
155	slash in all cases, paths without drive letters end up
156	relative to the current directory which isn't how
157	browsers work.
158
159	Some browsers accept \| instead of : as the drive letter
160	separator, so we do too.
161
162	On other platforms, we need the slash to indicate an
163	absolute pathname. On Windows, absolute paths start
164	with a drive letter.
165	*/
166	actual_path = real_path;
167	if((actual_path[0] == '/') &&
168	actual_path[1] &&
169	(actual_path[2] == ':' \|\| actual_path[2] == '\|')) {
170	actual_path[2] = ':';
171	actual_path++;
172	real_path_len--;
173	}
174
175	/* change path separators from '/' to '\\' for DOS, Windows and OS/2 */
176	for(i = 0; i < real_path_len; ++i)
177	if(actual_path[i] == '/')
178	actual_path[i] = '\\';
179	else if(!actual_path[i]) { /* binary zero */
180	Curl_safefree(real_path);
181	return CURLE_URL_MALFORMAT;
182	}
183
184	fd = open_readonly(actual_path, O_RDONLY\|O_BINARY);
185	file->path = actual_path;
186	#else
187	if(memchr(real_path, 0, real_path_len)) {	115✔
188	/* binary zeroes indicate foul play */
189	Curl_safefree(real_path);	×
190	return CURLE_URL_MALFORMAT;	×
191	}
192
193	fd = open_readonly(real_path, O_RDONLY);	115✔
194	file->path = real_path;	115✔
195	#endif
196	file->freepath = real_path; /* free this when done */	115✔
197
198	file->fd = fd;	115✔
199	if(!data->set.upload && (fd == -1)) {	115✔
200	failf(data, "Couldn't open file %s", data->state.up.path);	10✔
201	file_done(conn, CURLE_FILE_COULDNT_READ_FILE, FALSE);	10✔
202	return CURLE_FILE_COULDNT_READ_FILE;	10✔
203	}
204	*done = TRUE;	105✔
205
206	return CURLE_OK;	105✔
207	}
208
209	static CURLcode file_done(struct connectdata *conn,	105✔
210	CURLcode status, bool premature)
211	{
212	struct FILEPROTO *file = conn->data->req.protop;	105✔
213	(void)status; /* not used */
214	(void)premature; /* not used */
215
216	if(file) {	105✔
217	Curl_safefree(file->freepath);	105✔
218	file->path = NULL;	105✔
219	if(file->fd != -1)	105✔
220	close(file->fd);	91✔
221	file->fd = -1;	105✔
222	}
223
224	return CURLE_OK;	105✔
225	}
226
227	static CURLcode file_disconnect(struct connectdata *conn,	157✔
228	bool dead_connection)
229	{
230	struct FILEPROTO *file = conn->data->req.protop;	157✔
231	(void)dead_connection; /* not used */
232
233	if(file) {	157✔
234	Curl_safefree(file->freepath);	121✔
235	file->path = NULL;	121✔
236	if(file->fd != -1)	121✔
237	close(file->fd);	16✔
238	file->fd = -1;	121✔
239	}
240
241	return CURLE_OK;	157✔
242	}
243
244	#ifdef DOS_FILESYSTEM
245	#define DIRSEP '\\'
246	#else
247	#define DIRSEP '/'
248	#endif
249
250	static CURLcode file_upload(struct connectdata *conn)	4✔
251	{
252	struct FILEPROTO *file = conn->data->req.protop;	4✔
253	const char *dir = strchr(file->path, DIRSEP);	4✔
254	int fd;
255	int mode;
256	CURLcode result = CURLE_OK;	4✔
257	struct Curl_easy *data = conn->data;	4✔
258	char *buf = data->state.buffer;	4✔
259	curl_off_t bytecount = 0;	4✔
260	struct_stat file_stat;
261	const char *buf2;
262
263	/*
264	* Since FILE: doesn't do the full init, we need to provide some extra
265	* assignments here.
266	*/
267	conn->data->req.upload_fromhere = buf;	4✔
268
269	if(!dir)	4✔
270	return CURLE_FILE_COULDNT_READ_FILE; /* fix: better error code */	×
271
272	if(!dir[1])	4✔
273	return CURLE_FILE_COULDNT_READ_FILE; /* fix: better error code */	×
274
275	#ifdef O_BINARY
276	#define MODE_DEFAULT O_WRONLY\|O_CREAT\|O_BINARY
277	#else
278	#define MODE_DEFAULT O_WRONLY\|O_CREAT
279	#endif
280
281	if(data->state.resume_from)	4✔
282	mode = MODE_DEFAULT\|O_APPEND;	×
283	else
284	mode = MODE_DEFAULT\|O_TRUNC;	4✔
285
286	fd = open(file->path, mode, conn->data->set.new_file_perms);	4✔
287	if(fd < 0) {	4✔
288	failf(data, "Can't open %s for writing", file->path);	2✔
289	return CURLE_WRITE_ERROR;	2✔
290	}
291
292	if(-1 != data->state.infilesize)	2✔
293	/* known size of data to "upload" */
294	Curl_pgrsSetUploadSize(data, data->state.infilesize);	2✔
295
296	/* treat the negative resume offset value as the case of "-" */
297	if(data->state.resume_from < 0) {	2✔
298	if(fstat(fd, &file_stat)) {	×
299	close(fd);	×
300	failf(data, "Can't get the size of %s", file->path);	×
301	return CURLE_WRITE_ERROR;	×
302	}
303	data->state.resume_from = (curl_off_t)file_stat.st_size;	×
304	}
305
306	while(!result) {	6✔
307	size_t nread;
308	size_t nwrite;
309	size_t readcount;
310	result = Curl_fillreadbuffer(conn, data->set.buffer_size, &readcount);	4✔
311	if(result)	4✔
312	break;	2✔
313
314	if(readcount <= 0) /* fix questionable compare error. curlvms */	4✔
315	break;	2✔
316
317	nread = readcount;	2✔
318
319	/skip bytes before resume point/
320	if(data->state.resume_from) {	2✔
321	if((curl_off_t)nread <= data->state.resume_from) {	×
322	data->state.resume_from -= nread;	×
323	nread = 0;	×
324	buf2 = buf;	×
325	}
326	else {
327	buf2 = buf + data->state.resume_from;	×
328	nread -= (size_t)data->state.resume_from;	×
329	data->state.resume_from = 0;	×
330	}
331	}
332	else
333	buf2 = buf;	2✔
334
335	/* write the data to the target */
336	nwrite = write(fd, buf2, nread);	2✔
337	if(nwrite != nread) {	2✔
338	result = CURLE_SEND_ERROR;	×
339	break;	×
340	}
341
342	bytecount += nread;	2✔
343
344	Curl_pgrsSetUploadCounter(data, bytecount);	2✔
345
346	if(Curl_pgrsUpdate(conn))	2✔
347	result = CURLE_ABORTED_BY_CALLBACK;	×
348	else
349	result = Curl_speedcheck(data, Curl_now());	2✔
350	}
351	if(!result && Curl_pgrsUpdate(conn))	2✔
352	result = CURLE_ABORTED_BY_CALLBACK;	×
353
354	close(fd);	2✔
355
356	return result;	2✔
357	}
358
359	/*
360	* file_do() is the protocol-specific function for the do-phase, separated
361	* from the connect-phase above. Other protocols merely setup the transfer in
362	* the do-phase, to have it done in the main transfer loop but since some
363	* platforms we support don't allow select()ing etc on file handles (as
364	* opposed to sockets) we instead perform the whole do-operation in this
365	* function.
366	*/
367	static CURLcode file_do(struct connectdata conn, bool done)	95✔
368	{
369	/* This implementation ignores the host name in conformance with
370	RFC 1738. Only local files (reachable via the standard file system)
371	are supported. This means that files on remotely mounted directories
372	(via NFS, Samba, NT sharing) can be accessed through a file:// URL
373	*/
374	CURLcode result = CURLE_OK;	95✔
375	struct_stat statbuf; /* struct_stat instead of struct stat just to allow the
376	Windows version to have a different struct without
377	having to redefine the simple word 'stat' */
378	curl_off_t expected_size = 0;	95✔
379	bool size_known;
380	bool fstated = FALSE;	95✔
381	struct Curl_easy *data = conn->data;	95✔
382	char *buf = data->state.buffer;	95✔
383	curl_off_t bytecount = 0;	95✔
384	int fd;
385	struct FILEPROTO *file;
386
387	done = TRUE; / unconditionally */	95✔
388
389	Curl_pgrsStartNow(data);	95✔
390
391	if(data->set.upload)	95✔
392	return file_upload(conn);	4✔
393
394	file = conn->data->req.protop;	91✔
395
396	/* get the fd from the connection phase */
397	fd = file->fd;	91✔
398
399	/* VMS: This only works reliable for STREAMLF files */
400	if(-1 != fstat(fd, &statbuf)) {	91✔
401	/* we could stat it, then read out the size */
402	expected_size = statbuf.st_size;	91✔
403	/* and store the modification time */
404	data->info.filetime = statbuf.st_mtime;	91✔
405	fstated = TRUE;	91✔
406	}
407
408	if(fstated && !data->state.range && data->set.timecondition) {	91✔
409	if(!Curl_meets_timecondition(data, data->info.filetime)) {	×
410	*done = TRUE;	×
411	return CURLE_OK;	×
412	}
413	}
414
415	if(fstated) {	91✔
416	time_t filetime;
417	struct tm buffer;
418	const struct tm *tm = &buffer;	91✔
419	char header[80];
420	msnprintf(header, sizeof(header),	91✔
421	"Content-Length: %" CURL_FORMAT_CURL_OFF_T "\r\n",
422	expected_size);
423	result = Curl_client_write(conn, CLIENTWRITE_HEADER, header, 0);	91✔
424	if(result)	91✔
425	return result;	×
426
427	result = Curl_client_write(conn, CLIENTWRITE_HEADER,	91✔
428	(char *)"Accept-ranges: bytes\r\n", 0);
429	if(result)	91✔
430	return result;	×
431
432	filetime = (time_t)statbuf.st_mtime;	91✔
433	result = Curl_gmtime(filetime, &buffer);	91✔
434	if(result)	91✔
435	return result;	×
436
437	/* format: "Tue, 15 Nov 1994 12:45:26 GMT" */
438	msnprintf(header, sizeof(header),	364✔
439	"Last-Modified: %s, %02d %s %4d %02d:%02d:%02d GMT\r\n%s",
440	Curl_wkday[tm->tm_wday?tm->tm_wday-1:6],	91✔
441	tm->tm_mday,
442	Curl_month[tm->tm_mon],	91✔
443	tm->tm_year + 1900,	91✔
444	tm->tm_hour,
445	tm->tm_min,
446	tm->tm_sec,
447	data->set.opt_no_body ? "": "\r\n");	91✔
448	result = Curl_client_write(conn, CLIENTWRITE_HEADER, header, 0);	91✔
449	if(result)	91✔
450	return result;	×
451	/* set the file size to make it available post transfer */
452	Curl_pgrsSetDownloadSize(data, expected_size);	91✔
453	if(data->set.opt_no_body)	91✔
454	return result;	×
455	}
456
457	/* Check whether file range has been specified */
458	result = Curl_range(conn);	91✔
459	if(result)	91✔
460	return result;	×
461
462	/* Adjust the start offset in case we want to get the N last bytes
463	* of the stream if the filesize could be determined */
464	if(data->state.resume_from < 0) {	91✔
465	if(!fstated) {	2✔
466	failf(data, "Can't get the size of file.");	×
467	return CURLE_READ_ERROR;	×
468	}
469	data->state.resume_from += (curl_off_t)statbuf.st_size;	2✔
470	}
471
472	if(data->state.resume_from <= expected_size)	91✔
473	expected_size -= data->state.resume_from;	89✔
474	else {
475	failf(data, "failed to resume file:// transfer");	2✔
476	return CURLE_BAD_DOWNLOAD_RESUME;	2✔
477	}
478
479	/* A high water mark has been specified so we obey... */
480	if(data->req.maxdownload > 0)	89✔
481	expected_size = data->req.maxdownload;	8✔
482
483	if(!fstated \|\| (expected_size == 0))	89✔
484	size_known = FALSE;	4✔
485	else
486	size_known = TRUE;	85✔
487
488	/* The following is a shortcut implementation of file reading
489	this is both more efficient than the former call to download() and
490	it avoids problems with select() and recv() on file descriptors
491	in Winsock */
492	if(fstated)	89✔
493	Curl_pgrsSetDownloadSize(data, expected_size);	89✔
494
495	if(data->state.resume_from) {	89✔
496	if(data->state.resume_from !=	20✔
497	lseek(fd, data->state.resume_from, SEEK_SET))	10✔
498	return CURLE_BAD_DOWNLOAD_RESUME;	×
499	}
500
501	Curl_pgrsTime(data, TIMER_STARTTRANSFER);	89✔
502
503	while(!result) {	263✔
504	ssize_t nread;
505	/* Don't fill a whole buffer if we want less than all data */
506	size_t bytestoread;
507
508	if(size_known) {	174✔
509	bytestoread = (expected_size < data->set.buffer_size) ?	340✔
510	curlx_sotouz(expected_size) : (size_t)data->set.buffer_size;	170✔
511	}
512	else
513	bytestoread = data->set.buffer_size-1;	4✔
514
515	nread = read(fd, buf, bytestoread);	174✔
516
517	if(nread > 0)	174✔
518	buf[nread] = 0;	85✔
519
520	if(nread <= 0 \|\| (size_known && (expected_size == 0)))	174✔
521	break;
522
523	bytecount += nread;	85✔
524	if(size_known)	85✔
525	expected_size -= nread;	85✔
526
527	result = Curl_client_write(conn, CLIENTWRITE_BODY, buf, nread);	85✔
528	if(result)	85✔
529	return result;	×
530
531	Curl_pgrsSetDownloadCounter(data, bytecount);	85✔
532
533	if(Curl_pgrsUpdate(conn))	85✔
534	result = CURLE_ABORTED_BY_CALLBACK;	×
535	else
536	result = Curl_speedcheck(data, Curl_now());	85✔
537	}
538	if(Curl_pgrsUpdate(conn))	89✔
539	result = CURLE_ABORTED_BY_CALLBACK;	×
540
541	return result;	89✔
542	}
543
544	#endif

curl / curl / 9535

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous