43 #ifdef CURL_DO_LINEEND_CONV 51 char *startPtr,
size_t size)
56 if((startPtr == NULL) || (size < 1)) {
63 if(*startPtr ==
'\n') {
66 memmove(startPtr, startPtr + 1, size-1);
75 inPtr = outPtr = memchr(startPtr,
'\r', size);
78 while(inPtr < (startPtr + size-1)) {
80 if(memcmp(inPtr,
"\r\n", 2) == 0) {
101 if(inPtr < startPtr + size) {
115 if(outPtr < startPtr + size)
119 return (outPtr - startPtr);
125 #ifdef USE_RECV_BEFORE_SEND_WORKAROUND 128 struct postponed_data *
const psnd = &(conn->postponed[sockindex]);
129 return psnd->buffer && psnd->allocated_size &&
130 psnd->recv_size > psnd->recv_processed;
136 struct postponed_data *
const psnd = &(conn->postponed[num]);
137 size_t bytestorecv = psnd->allocated_size - psnd->recv_size;
145 (!psnd->buffer || bytestorecv)) {
153 psnd->buffer =
malloc(psnd->allocated_size);
155 psnd->recv_processed = 0;
157 psnd->bindsock = sockfd;
159 bytestorecv = psnd->allocated_size;
164 recvedbytes = sread(sockfd, psnd->buffer + psnd->recv_size,
167 psnd->recv_size += recvedbytes;
170 psnd->allocated_size = 0;
178 struct postponed_data *
const psnd = &(conn->postponed[num]);
184 DEBUGASSERT(psnd->recv_size <= psnd->allocated_size);
185 DEBUGASSERT(psnd->recv_processed <= psnd->recv_size);
188 if(psnd->recv_size > psnd->recv_processed) {
190 copysize =
CURLMIN(len, psnd->recv_size - psnd->recv_processed);
191 memcpy(
buf, psnd->buffer + psnd->recv_processed, copysize);
192 psnd->recv_processed += copysize;
198 if(psnd->recv_processed == psnd->recv_size) {
201 psnd->allocated_size = 0;
203 psnd->recv_processed = 0;
218 #define pre_receive_plain(c,n) do {} WHILE_FALSE 219 #define get_pre_recved(c,n,b,l) 0 229 char print_buffer[2048 + 1];
231 vsnprintf(print_buffer,
sizeof(print_buffer), fmt, ap);
233 len = strlen(print_buffer);
267 const char *fmt, ...)
283 write_len = strlen(s);
288 result =
Curl_write(conn, sockfd, sptr, write_len, &bytes_written);
296 if((
size_t)bytes_written != write_len) {
299 write_len -= bytes_written;
300 sptr += bytes_written;
328 bytes_written = conn->
send[num](conn, num, mem,
len, &
result);
330 *written = bytes_written;
331 if(bytes_written >= 0)
365 bytes_written =
sendto(sockfd, mem, len, MSG_FASTOPEN,
371 bytes_written = swrite(sockfd, mem, len);
374 if(-1 == bytes_written) {
378 #ifdef WSAEWOULDBLOCK
380 (WSAEWOULDBLOCK == err)
385 (EWOULDBLOCK == err) || (
EAGAIN == err) || (EINTR == err) ||
400 return bytes_written;
420 *written = bytes_written;
438 nread = sread(sockfd, buf, len);
445 #ifdef WSAEWOULDBLOCK
447 (WSAEWOULDBLOCK == err)
452 (EWOULDBLOCK == err) || (
EAGAIN == err) || (EINTR == err)
528 DEBUGF(
infof(data,
"Paused %zu bytes in buffer for type %02x\n",
574 size_t wrote = writebody(ptr, 1, chunklen, data->
set.
out);
581 failf(data,
"Write callback asked for PAUSE when not supported!");
586 if(wrote != chunklen) {
587 failf(data,
"Failed writing body (%zu != %zu)", wrote, chunklen);
593 size_t wrote = writeheader(ptr, 1, chunklen, data->
set.
writeheader);
599 return pausewrite(data, CLIENTWRITE_HEADER, ptr, len);
601 if(wrote != chunklen) {
602 failf(data,
"Failed writing header");
646 #ifdef CURL_DO_LINEEND_CONV 657 size_t bytesfromsocket,
660 ssize_t nread = sread(sockfd, buf, bytesfromsocket);
666 return_error = WSAEWOULDBLOCK == err;
668 return_error = EWOULDBLOCK == err ||
EAGAIN == err || EINTR == err;
689 size_t sizerequested,
694 size_t bytesfromsocket = 0;
695 char *buffertofill = NULL;
715 if(bytestocopy > 0) {
733 nread = conn->
recv[num](conn, num, buffertofill, bytesfromsocket, &
result);
753 "* ",
"< ",
"> ",
"{ ",
"} ",
"{ ",
"} " };
756 #ifdef CURL_DOES_CONVERSIONS 758 size_t conv_size = 0;
773 for(i = 0; i < size-4; i++) {
774 if(memcmp(&buf[i],
"\x0d\x0a\x0d\x0a", 4) == 0) {
802 #ifdef CURL_DOES_CONVERSIONS 803 if(size != conv_size) {
813 #ifdef CURL_DOES_CONVERSIONS 826 const char *
t = NULL;
827 const char *
w =
"Data";
846 snprintf(buffer,
sizeof(buffer),
"[%s %s %s]", w, t,
853 rc =
showit(data, type, ptr, size);
int Curl_debug(struct Curl_easy *data, curl_infotype type, char *ptr, size_t size, struct connectdata *conn)
bool prev_block_had_trailing_cr
static size_t convert_lineends(struct Curl_easy *data, char *startPtr, size_t size)
static int showit(struct Curl_easy *data, curl_infotype type, char *ptr, size_t size)
CURLcode Curl_client_chop_write(struct connectdata *conn, int type, char *ptr, size_t len)
#define CURL_WRITEFUNC_PAUSE
CURLcode Curl_write_plain(struct connectdata *conn, curl_socket_t sockfd, const void *mem, size_t len, ssize_t *written)
const struct Curl_handler * handler
#define CURL_MAX_WRITE_SIZE
struct Curl_multi * multi
UNITTEST_START char * ptr
void * Curl_memdup(const void *src, size_t length)
#define get_pre_recved(c, n, b, l)
bool Curl_pipeline_wanted(const struct Curl_multi *multi, int bits)
#define realloc(ptr, size)
void Curl_failf(struct Curl_easy *data, const char *fmt,...)
geometry_msgs::TransformStamped t
UNITTEST_START int result
struct sockaddr * ai_addr
CURLcode Curl_read_plain(curl_socket_t sockfd, char *buf, size_t bytesfromsocket, ssize_t *n)
memcpy(filename, filename1, strlen(filename1))
static CURLcode pausewrite(struct Curl_easy *data, int type, const char *ptr, size_t len)
const char * Curl_strerror(struct connectdata *conn, int err)
#define pre_receive_plain(c, n)
#define Curl_convert_from_network(a, b, c)
#define BUNDLE_PIPELINING
struct tempbuf tempwrite[3]
#define CLIENTWRITE_HEADER
void Curl_infof(struct Curl_easy *data, const char *fmt,...)
CURLcode Curl_write(struct connectdata *conn, curl_socket_t sockfd, const void *mem, size_t len, ssize_t *written)
CURLcode Curl_client_write(struct connectdata *conn, int type, char *ptr, size_t len)
#define PROTOPT_NONETWORK
int Curl_socket_check(curl_socket_t readfd0, curl_socket_t readfd1, curl_socket_t writefd, time_t timeout_ms)
TFSIMD_FORCE_INLINE const tfScalar & w() const
curl_write_callback fwrite_func
ssize_t Curl_send_plain(struct connectdata *conn, int num, const void *mem, size_t len, CURLcode *code)
size_t(* curl_write_callback)(char *buffer, size_t size, size_t nitems, void *outstream)
bool Curl_recv_has_postponed_data(struct connectdata *conn, int sockindex)
struct connectbundle * bundle
curl_off_t crlf_conversions
curl_socklen_t ai_addrlen
ssize_t Curl_recv_plain(struct connectdata *conn, int num, char *buf, size_t len, CURLcode *code)
curl_write_callback fwrite_header
curl_debug_callback fdebug
union connectdata::@34 proto
CURLcode Curl_sendf(curl_socket_t sockfd, struct connectdata *conn, const char *fmt,...)
#define PROTO_FAMILY_HTTP
CURLcode Curl_read(struct connectdata *conn, curl_socket_t sockfd, char *buf, size_t sizerequested, ssize_t *n)