| /***************************************************************************** |
| * _ _ ____ _ |
| * Project ___| | | | _ \| | |
| * / __| | | | |_) | | |
| * | (__| |_| | _ <| |___ |
| * \___|\___/|_| \_\_____| |
| * |
| * Copyright (C) 2000, Daniel Stenberg, <daniel@haxx.se>, et al. |
| * |
| * In order to be useful for every potential user, curl and libcurl are |
| * dual-licensed under the MPL and the MIT/X-derivate licenses. |
| * |
| * 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 MPL or the MIT/X-derivate |
| * licenses. You may pick one of these licenses. |
| * |
| * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY |
| * KIND, either express or implied. |
| * |
| * $Id$ |
| *****************************************************************************/ |
| |
| #include "setup.h" |
| |
| #include <stdio.h> |
| #include <stdarg.h> |
| #include <stdlib.h> |
| |
| #ifdef HAVE_UNISTD_H |
| #include <unistd.h> |
| #endif |
| #if defined(WIN32) && !defined(__GNUC__) || defined(__MINGW32__) |
| #include <winsock.h> |
| #endif |
| |
| #include <curl/curl.h> |
| #include "urldata.h" |
| #include "sendf.h" |
| |
| #define _MPRINTF_REPLACE /* use the internal *printf() functions */ |
| #include <curl/mprintf.h> |
| |
| #ifdef KRB4 |
| #include "security.h" |
| #endif |
| #include <string.h> |
| /* The last #include file should be: */ |
| #ifdef MALLOCDEBUG |
| #include "memdebug.h" |
| #endif |
| |
| /* infof() is for info message along the way */ |
| |
| void Curl_infof(struct UrlData *data, char *fmt, ...) |
| { |
| va_list ap; |
| if(data->bits.verbose) { |
| va_start(ap, fmt); |
| fputs("* ", data->err); |
| vfprintf(data->err, fmt, ap); |
| va_end(ap); |
| } |
| } |
| |
| /* failf() is for messages stating why we failed, the LAST one will be |
| returned for the user (if requested) */ |
| |
| void Curl_failf(struct UrlData *data, char *fmt, ...) |
| { |
| va_list ap; |
| va_start(ap, fmt); |
| if(data->errorbuffer) |
| vsnprintf(data->errorbuffer, CURL_ERROR_SIZE, fmt, ap); |
| else /* no errorbuffer receives this, write to data->err instead */ |
| vfprintf(data->err, fmt, ap); |
| va_end(ap); |
| } |
| |
| /* sendf() sends the formated data to the server */ |
| size_t Curl_sendf(int fd, struct UrlData *data, char *fmt, ...) |
| { |
| size_t bytes_written; |
| char *s; |
| va_list ap; |
| va_start(ap, fmt); |
| s = vaprintf(fmt, ap); |
| va_end(ap); |
| if(!s) |
| return 0; /* failure */ |
| if(data->bits.verbose) |
| fprintf(data->err, "> %s", s); |
| |
| #ifndef USE_SSLEAY |
| bytes_written = swrite(fd, s, strlen(s)); |
| #else /* USE_SSLEAY */ |
| if (data->ssl.use) { |
| bytes_written = SSL_write(data->ssl.handle, s, strlen(s)); |
| } else { |
| bytes_written = swrite(fd, s, strlen(s)); |
| } |
| #endif /* USE_SSLEAY */ |
| free(s); /* free the output string */ |
| return(bytes_written); |
| } |
| |
| /* ssend() sends plain (binary) data to the server */ |
| size_t Curl_ssend(int fd, struct connectdata *conn, void *mem, size_t len) |
| { |
| size_t bytes_written; |
| struct UrlData *data=conn->data; /* conn knows data, not vice versa */ |
| |
| #ifdef USE_SSLEAY |
| if (data->ssl.use) { |
| bytes_written = SSL_write(data->ssl.handle, mem, len); |
| } |
| else { |
| #endif |
| #ifdef KRB4 |
| if(conn->sec_complete) { |
| bytes_written = sec_write(conn, fd, mem, len); |
| } |
| else |
| #endif /* KRB4 */ |
| bytes_written = swrite(fd, mem, len); |
| #ifdef USE_SSLEAY |
| } |
| #endif |
| |
| return bytes_written; |
| } |
| |
| /* client_write() sends data to the write callback(s) |
| |
| The bit pattern defines to what "streams" to write to. Body and/or header. |
| The defines are in sendf.h of course. |
| */ |
| CURLcode Curl_client_write(struct UrlData *data, |
| int type, |
| char *ptr, |
| size_t len) |
| { |
| size_t wrote; |
| |
| if(0 == len) |
| len = strlen(ptr); |
| |
| if(type & CLIENTWRITE_BODY) { |
| wrote = data->fwrite(ptr, 1, len, data->out); |
| if(wrote != len) { |
| failf (data, "Failed writing body"); |
| return CURLE_WRITE_ERROR; |
| } |
| } |
| if((type & CLIENTWRITE_HEADER) && data->writeheader) { |
| wrote = data->fwrite(ptr, 1, len, data->writeheader); |
| if(wrote != len) { |
| failf (data, "Failed writing header"); |
| return CURLE_WRITE_ERROR; |
| } |
| } |
| |
| return CURLE_OK; |
| } |
| |