#include "setup.h"
#ifdef HAVE_SYS_SOCKET_H
#include <sys/socket.h>
#endif
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#include <curl/curl.h>
#include "urldata.h"
#include "sendf.h"
#include "connect.h"
#include "sslgen.h"
#include "ssh.h"
#include "multiif.h"
#include "non-ascii.h"
#define _MPRINTF_REPLACE
#include <curl/mprintf.h>
#if !defined(CURL_DISABLE_FTP) && (defined(HAVE_KRB4) || defined(HAVE_GSSAPI))
#include "krb4.h"
#else
#define Curl_sec_send(a,b,c,d) -1
#define Curl_sec_read(a,b,c,d) -1
#endif
#include "curl_memory.h"
#include "strerror.h"
#include "memdebug.h"
#ifdef CURL_DO_LINEEND_CONV
static size_t convert_lineends(struct SessionHandle *data,
char *startPtr, size_t size)
{
char *inPtr, *outPtr;
if((startPtr == NULL) || (size < 1)) {
return(size);
}
if(data->state.prev_block_had_trailing_cr) {
if(*startPtr == '\n') {
memmove(startPtr, startPtr+1, size-1);
size--;
data->state.crlf_conversions++;
}
data->state.prev_block_had_trailing_cr = FALSE;
}
inPtr = outPtr = memchr(startPtr, '\r', size);
if(inPtr) {
while(inPtr < (startPtr+size-1)) {
if(memcmp(inPtr, "\r\n", 2) == 0) {
inPtr++;
*outPtr = *inPtr;
data->state.crlf_conversions++;
}
else {
if(*inPtr == '\r') {
*outPtr = '\n';
}
else {
*outPtr = *inPtr;
}
}
outPtr++;
inPtr++;
}
if(inPtr < startPtr+size) {
if(*inPtr == '\r') {
*outPtr = '\n';
data->state.prev_block_had_trailing_cr = TRUE;
}
else {
*outPtr = *inPtr;
}
outPtr++;
}
if(outPtr < startPtr+size)
*outPtr = '\0';
return(outPtr - startPtr);
}
return(size);
}
#endif
void Curl_infof(struct SessionHandle *data, const char *fmt, ...)
{
if(data && data->set.verbose) {
va_list ap;
size_t len;
char print_buffer[2048 + 1];
va_start(ap, fmt);
vsnprintf(print_buffer, sizeof(print_buffer), fmt, ap);
va_end(ap);
len = strlen(print_buffer);
Curl_debug(data, CURLINFO_TEXT, print_buffer, len, NULL);
}
}
void Curl_failf(struct SessionHandle *data, const char *fmt, ...)
{
va_list ap;
size_t len;
va_start(ap, fmt);
vsnprintf(data->state.buffer, BUFSIZE, fmt, ap);
if(data->set.errorbuffer && !data->state.errorbuf) {
snprintf(data->set.errorbuffer, CURL_ERROR_SIZE, "%s", data->state.buffer);
data->state.errorbuf = TRUE;
}
if(data->set.verbose) {
len = strlen(data->state.buffer);
if(len < BUFSIZE - 1) {
data->state.buffer[len] = '\n';
data->state.buffer[++len] = '\0';
}
Curl_debug(data, CURLINFO_TEXT, data->state.buffer, len, NULL);
}
va_end(ap);
}
CURLcode Curl_sendf(curl_socket_t sockfd, struct connectdata *conn,
const char *fmt, ...)
{
struct SessionHandle *data = conn->data;
ssize_t bytes_written;
size_t write_len;
CURLcode res = CURLE_OK;
char *s;
char *sptr;
va_list ap;
va_start(ap, fmt);
s = vaprintf(fmt, ap);
va_end(ap);
if(!s)
return CURLE_OUT_OF_MEMORY;
bytes_written=0;
write_len = strlen(s);
sptr = s;
for(;;) {
res = Curl_write(conn, sockfd, sptr, write_len, &bytes_written);
if(CURLE_OK != res)
break;
if(data->set.verbose)
Curl_debug(data, CURLINFO_DATA_OUT, sptr, (size_t)bytes_written, conn);
if((size_t)bytes_written != write_len) {
write_len -= bytes_written;
sptr += bytes_written;
}
else
break;
}
free(s);
return res;
}
CURLcode Curl_write(struct connectdata *conn,
curl_socket_t sockfd,
const void *mem,
size_t len,
ssize_t *written)
{
ssize_t bytes_written;
CURLcode curlcode = CURLE_OK;
int num = (sockfd == conn->sock[SECONDARYSOCKET]);
bytes_written = conn->send[num](conn, num, mem, len, &curlcode);
*written = bytes_written;
if(bytes_written >= 0)
return CURLE_OK;
switch(curlcode) {
case CURLE_AGAIN:
*written = 0;
return CURLE_OK;
case CURLE_OK:
return CURLE_SEND_ERROR;
default:
return (CURLcode)curlcode;
}
}
ssize_t Curl_send_plain(struct connectdata *conn, int num,
const void *mem, size_t len, CURLcode *code)
{
curl_socket_t sockfd = conn->sock[num];
ssize_t bytes_written = swrite(sockfd, mem, len);
*code = CURLE_OK;
if(-1 == bytes_written) {
int err = SOCKERRNO;
if(
#ifdef WSAEWOULDBLOCK
(WSAEWOULDBLOCK == err)
#else
(EWOULDBLOCK == err) || (EAGAIN == err) || (EINTR == err)
#endif
) {
bytes_written=0;
*code = CURLE_AGAIN;
}
else {
failf(conn->data, "Send failure: %s",
Curl_strerror(conn, err));
conn->data->state.os_errno = err;
*code = CURLE_SEND_ERROR;
}
}
return bytes_written;
}
CURLcode Curl_write_plain(struct connectdata *conn,
curl_socket_t sockfd,
const void *mem,
size_t len,
ssize_t *written)
{
ssize_t bytes_written;
CURLcode retcode;
int num = (sockfd == conn->sock[SECONDARYSOCKET]);
bytes_written = Curl_send_plain(conn, num, mem, len, &retcode);
*written = bytes_written;
return retcode;
}
ssize_t Curl_recv_plain(struct connectdata *conn, int num, char *buf,
size_t len, CURLcode *code)
{
curl_socket_t sockfd = conn->sock[num];
ssize_t nread = sread(sockfd, buf, len);
*code = CURLE_OK;
if(-1 == nread) {
int err = SOCKERRNO;
if(
#ifdef WSAEWOULDBLOCK
(WSAEWOULDBLOCK == err)
#else
(EWOULDBLOCK == err) || (EAGAIN == err) || (EINTR == err)
#endif
) {
*code = CURLE_AGAIN;
}
else {
failf(conn->data, "Recv failure: %s",
Curl_strerror(conn, err));
conn->data->state.os_errno = err;
*code = CURLE_RECV_ERROR;
}
}
return nread;
}
static CURLcode pausewrite(struct SessionHandle *data,
int type,
const char *ptr,
size_t len)
{
struct SingleRequest *k = &data->req;
char *dupl = malloc(len);
if(!dupl)
return CURLE_OUT_OF_MEMORY;
memcpy(dupl, ptr, len);
data->state.tempwrite = dupl;
data->state.tempwritesize = len;
data->state.tempwritetype = type;
k->keepon |= KEEP_RECV_PAUSE;
DEBUGF(infof(data, "Pausing with %zu bytes in buffer for type %02x\n",
len, type));
return CURLE_OK;
}
CURLcode Curl_client_write(struct connectdata *conn,
int type,
char *ptr,
size_t len)
{
struct SessionHandle *data = conn->data;
size_t wrote;
if(0 == len)
len = strlen(ptr);
if(data->req.keepon & KEEP_RECV_PAUSE) {
size_t newlen;
char *newptr;
if(type != data->state.tempwritetype)
return CURLE_RECV_ERROR;
DEBUGASSERT(data->state.tempwrite);
newlen = len + data->state.tempwritesize;
newptr = realloc(data->state.tempwrite, newlen);
if(!newptr)
return CURLE_OUT_OF_MEMORY;
memcpy(newptr + data->state.tempwritesize, ptr, len);
data->state.tempwrite = newptr;
data->state.tempwritesize = newlen;
return CURLE_OK;
}
if(type & CLIENTWRITE_BODY) {
if((conn->handler->protocol&CURLPROTO_FTP) &&
conn->proto.ftpc.transfertype == 'A') {
CURLcode rc = Curl_convert_from_network(data, ptr, len);
if(rc)
return rc;
#ifdef CURL_DO_LINEEND_CONV
len = convert_lineends(data, ptr, len);
#endif
}
if(len) {
wrote = data->set.fwrite_func(ptr, 1, len, data->set.out);
}
else {
wrote = len;
}
if(CURL_WRITEFUNC_PAUSE == wrote)
return pausewrite(data, type, ptr, len);
if(wrote != len) {
failf(data, "Failed writing body (%zu != %zu)", wrote, len);
return CURLE_WRITE_ERROR;
}
}
if((type & CLIENTWRITE_HEADER) &&
(data->set.fwrite_header || data->set.writeheader) ) {
curl_write_callback writeit=
data->set.fwrite_header?data->set.fwrite_header:data->set.fwrite_func;
wrote = writeit(ptr, 1, len, data->set.writeheader);
if(CURL_WRITEFUNC_PAUSE == wrote)
return pausewrite(data, CLIENTWRITE_HEADER, ptr, len);
if(wrote != len) {
failf (data, "Failed writing header");
return CURLE_WRITE_ERROR;
}
}
return CURLE_OK;
}
CURLcode Curl_read_plain(curl_socket_t sockfd,
char *buf,
size_t bytesfromsocket,
ssize_t *n)
{
ssize_t nread = sread(sockfd, buf, bytesfromsocket);
if(-1 == nread) {
int err = SOCKERRNO;
#ifdef USE_WINSOCK
if(WSAEWOULDBLOCK == err)
#else
if((EWOULDBLOCK == err) || (EAGAIN == err) || (EINTR == err))
#endif
return CURLE_AGAIN;
else
return CURLE_RECV_ERROR;
}
*n = nread;
return CURLE_OK;
}
CURLcode Curl_read(struct connectdata *conn,
curl_socket_t sockfd,
char *buf,
size_t sizerequested,
ssize_t *n)
{
CURLcode curlcode = CURLE_RECV_ERROR;
ssize_t nread = 0;
size_t bytesfromsocket = 0;
char *buffertofill = NULL;
bool pipelining = (conn->data->multi &&
Curl_multi_canPipeline(conn->data->multi)) ? TRUE : FALSE;
int num = (sockfd == conn->sock[SECONDARYSOCKET]);
*n=0;
if(pipelining) {
size_t bytestocopy = CURLMIN(conn->buf_len - conn->read_pos,
sizerequested);
if(bytestocopy > 0) {
memcpy(buf, conn->master_buffer + conn->read_pos, bytestocopy);
conn->read_pos += bytestocopy;
conn->bits.stream_was_rewound = FALSE;
*n = (ssize_t)bytestocopy;
return CURLE_OK;
}
bytesfromsocket = CURLMIN(sizerequested, BUFSIZE * sizeof (char));
buffertofill = conn->master_buffer;
}
else {
bytesfromsocket = CURLMIN((long)sizerequested,
conn->data->set.buffer_size ?
conn->data->set.buffer_size : BUFSIZE);
buffertofill = buf;
}
nread = conn->recv[num](conn, num, buffertofill, bytesfromsocket, &curlcode);
if(nread < 0)
return curlcode;
if(pipelining) {
memcpy(buf, conn->master_buffer, nread);
conn->buf_len = nread;
conn->read_pos = nread;
}
*n += nread;
return CURLE_OK;
}
static int showit(struct SessionHandle *data, curl_infotype type,
char *ptr, size_t size)
{
static const char s_infotype[CURLINFO_END][3] = {
"* ", "< ", "> ", "{ ", "} ", "{ ", "} " };
#ifdef CURL_DOES_CONVERSIONS
char buf[BUFSIZE+1];
size_t conv_size = 0;
switch(type) {
case CURLINFO_HEADER_OUT:
if(size > BUFSIZE) {
size = BUFSIZE;
buf[BUFSIZE] = '\0';
}
conv_size = size;
memcpy(buf, ptr, size);
if(size > 4) {
size_t i;
for(i = 0; i < size-4; i++) {
if(memcmp(&buf[i], "\x0d\x0a\x0d\x0a", 4) == 0) {
conv_size = i + 4;
break;
}
}
}
Curl_convert_from_network(data, buf, conv_size);
ptr = buf;
break;
default:
break;
}
#endif
if(data->set.fdebug)
return (*data->set.fdebug)(data, type, ptr, size,
data->set.debugdata);
switch(type) {
case CURLINFO_TEXT:
case CURLINFO_HEADER_OUT:
case CURLINFO_HEADER_IN:
fwrite(s_infotype[type], 2, 1, data->set.err);
fwrite(ptr, size, 1, data->set.err);
#ifdef CURL_DOES_CONVERSIONS
if(size != conv_size) {
fwrite("\n", 1, 1, data->set.err);
}
#endif
break;
default:
break;
}
return 0;
}
int Curl_debug(struct SessionHandle *data, curl_infotype type,
char *ptr, size_t size,
struct connectdata *conn)
{
int rc;
if(data->set.printhost && conn && conn->host.dispname) {
char buffer[160];
const char *t=NULL;
const char *w="Data";
switch (type) {
case CURLINFO_HEADER_IN:
w = "Header";
case CURLINFO_DATA_IN:
t = "from";
break;
case CURLINFO_HEADER_OUT:
w = "Header";
case CURLINFO_DATA_OUT:
t = "to";
break;
default:
break;
}
if(t) {
snprintf(buffer, sizeof(buffer), "[%s %s %s]", w, t,
conn->host.dispname);
rc = showit(data, CURLINFO_TEXT, buffer, strlen(buffer));
if(rc)
return rc;
}
}
rc = showit(data, type, ptr, size);
return rc;
}