-/*****************************************************************************
+/***************************************************************************
* _ _ ____ _
* Project ___| | | | _ \| |
* / __| | | | |_) | |
* | (__| |_| | _ <| |___
* \___|\___/|_| \_\_____|
*
+ * Copyright (C) 1998 - 2014, Daniel Stenberg, <daniel@haxx.se>, et al.
*
- * This is an example application source code sending SMTP mail using the
- * multi interface.
- */
-
+ * 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 <string.h>
#include <curl/curl.h>
-/*
- * This is the list of basic details you need to tweak to get things right.
+/* This is an example showing how to send mail using libcurl's SMTP
+ * capabilities. It builds on the smtp-mail.c example to demonstrate how to use
+ * libcurl's multi interface.
+ *
+ * Note that this example requires libcurl 7.20.0 or above.
*/
-#define USERNAME "user@example.com"
-#define PASSWORD "123qwerty"
-#define SMTPSERVER "smtp.example.com"
-#define SMTPPORT ":587" /* it is a colon+port string, but you can set it
- to "" to use the default port */
-#define RECEPIENT "receipient@example.com"
-#define MAILFROM "<realuser@example.com>"
+
+#define FROM "<sender@example.com>"
+#define TO "<recipient@example.com>"
+#define CC "<info@example.com>"
#define MULTI_PERFORM_HANG_TIMEOUT 60 * 1000
-/* Note that you should include the actual meta data headers here as well if
- you want the mail to have a Subject, another From:, show a To: or whatever
- you think your mail should feature! */
-static const char *text[]={
- "one\n",
- "two\n",
- "three\n",
- " Hello, this is CURL email SMTP\n",
+static const char *payload_text[] = {
+ "Date: Mon, 29 Nov 2010 21:54:29 +1100\r\n",
+ "To: " TO "\r\n",
+ "From: " FROM "(Example User)\r\n",
+ "Cc: " CC "(Another example User)\r\n",
+ "Message-ID: <dcd7cb36-11db-487a-9f3a-e652a9458efd@rfcpedant.example.org>\r\n",
+ "Subject: SMTP multi example message\r\n",
+ "\r\n", /* empty line to divide headers from body, see RFC5322 */
+ "The body of the message starts here.\r\n",
+ "\r\n",
+ "It could be a lot of lines, could be MIME encoded, whatever.\r\n",
+ "Check RFC5322.\r\n",
NULL
};
-struct WriteThis {
- int counter;
+struct upload_status {
+ int lines_read;
};
-static size_t read_callback(void *ptr, size_t size, size_t nmemb, void *userp)
+static size_t payload_source(void *ptr, size_t size, size_t nmemb, void *userp)
{
- struct WriteThis *pooh = (struct WriteThis *)userp;
+ struct upload_status *upload_ctx = (struct upload_status *)userp;
const char *data;
- if(size*nmemb < 1)
+ if((size == 0) || (nmemb == 0) || ((size*nmemb) < 1)) {
return 0;
+ }
- data = text[pooh->counter];
+ data = payload_text[upload_ctx->lines_read];
if(data) {
size_t len = strlen(data);
memcpy(ptr, data, len);
- pooh->counter++; /* advance pointer */
+ upload_ctx->lines_read++;
+
return len;
}
- return 0; /* no more data left to deliver */
+
+ return 0;
}
static struct timeval tvnow(void)
{
- /*
- ** time() returns the value of time in seconds since the Epoch.
- */
struct timeval now;
+
+ /* time() returns the value of time in seconds since the epoch */
now.tv_sec = (long)time(NULL);
now.tv_usec = 0;
+
return now;
}
static long tvdiff(struct timeval newer, struct timeval older)
{
- return (newer.tv_sec-older.tv_sec)*1000+
- (newer.tv_usec-older.tv_usec)/1000;
+ return (newer.tv_sec - older.tv_sec) * 1000 +
+ (newer.tv_usec - older.tv_usec) / 1000;
}
int main(void)
{
- CURL *curl;
- CURLM *mcurl;
- int still_running = 1;
- struct timeval mp_start;
- char mp_timedout = 0;
- struct WriteThis pooh;
- struct curl_slist* rcpt_list = NULL;
+ CURL *curl;
+ CURLM *mcurl;
+ int still_running = 1;
+ struct timeval mp_start;
+ struct curl_slist *recipients = NULL;
+ struct upload_status upload_ctx;
+
+ upload_ctx.lines_read = 0;
- pooh.counter = 0;
+ curl_global_init(CURL_GLOBAL_DEFAULT);
- curl_global_init(CURL_GLOBAL_DEFAULT);
+ curl = curl_easy_init();
+ if(!curl)
+ return 1;
- curl = curl_easy_init();
- if(!curl)
- return 1;
+ mcurl = curl_multi_init();
+ if(!mcurl)
+ return 2;
- mcurl = curl_multi_init();
- if(!mcurl)
- return 2;
+ /* This is the URL for your mailserver */
+ curl_easy_setopt(curl, CURLOPT_URL, "smtp://mail.example.com");
- rcpt_list = curl_slist_append(rcpt_list, RECEPIENT);
- /* more addresses can be added here
- rcpt_list = curl_slist_append(rcpt_list, "others@example.com");
+ /* Note that this option isn't strictly required, omitting it will result in
+ * libcurl sending the MAIL FROM command with empty sender data. All
+ * autoresponses should have an empty reverse-path, and should be directed
+ * to the address in the reverse-path which triggered them. Otherwise, they
+ * could cause an endless loop. See RFC 5321 Section 4.5.5 for more details.
*/
+ curl_easy_setopt(curl, CURLOPT_MAIL_FROM, FROM);
- curl_easy_setopt(curl, CURLOPT_URL, "smtp://" SMTPSERVER SMTPPORT);
- curl_easy_setopt(curl, CURLOPT_USERNAME, USERNAME);
- curl_easy_setopt(curl, CURLOPT_PASSWORD, PASSWORD);
- curl_easy_setopt(curl, CURLOPT_READFUNCTION, read_callback);
- curl_easy_setopt(curl, CURLOPT_MAIL_FROM, MAILFROM);
- curl_easy_setopt(curl, CURLOPT_MAIL_RCPT, rcpt_list);
- curl_easy_setopt(curl, CURLOPT_USE_SSL, CURLUSESSL_ALL);
- curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER,0);
- curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0);
- curl_easy_setopt(curl, CURLOPT_READDATA, &pooh);
- curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
- curl_easy_setopt(curl, CURLOPT_SSLVERSION, 0);
- curl_easy_setopt(curl, CURLOPT_SSL_SESSIONID_CACHE, 0);
- curl_multi_add_handle(mcurl, curl);
-
- mp_timedout = 0;
- mp_start = tvnow();
-
- /* we start some action by calling perform right away */
+ /* Add two recipients, in this particular case they correspond to the
+ * To: and Cc: addressees in the header, but they could be any kind of
+ * recipient. */
+ recipients = curl_slist_append(recipients, TO);
+ recipients = curl_slist_append(recipients, CC);
+ curl_easy_setopt(curl, CURLOPT_MAIL_RCPT, recipients);
+
+ /* We're using a callback function to specify the payload (the headers and
+ * body of the message). You could just use the CURLOPT_READDATA option to
+ * specify a FILE pointer to read from. */
+ curl_easy_setopt(curl, CURLOPT_READFUNCTION, payload_source);
+ curl_easy_setopt(curl, CURLOPT_READDATA, &upload_ctx);
+ curl_easy_setopt(curl, CURLOPT_UPLOAD, 1L);
+
+ /* Tell the multi stack about our easy handle */
+ curl_multi_add_handle(mcurl, curl);
+
+ /* Record the start time which we can use later */
+ mp_start = tvnow();
+
+ /* We start some action by calling perform right away */
curl_multi_perform(mcurl, &still_running);
while(still_running) {
struct timeval timeout;
- int rc; /* select() return code */
-
fd_set fdread;
fd_set fdwrite;
fd_set fdexcep;
int maxfd = -1;
+ int rc;
+ CURLMcode mc; /* curl_multi_fdset() return code */
long curl_timeo = -1;
+ /* Initialise the file descriptors */
FD_ZERO(&fdread);
FD_ZERO(&fdwrite);
FD_ZERO(&fdexcep);
- /* set a suitable timeout to play around with */
+ /* Set a suitable timeout to play around with */
timeout.tv_sec = 1;
timeout.tv_usec = 0;
}
/* get file descriptors from the transfers */
- curl_multi_fdset(mcurl, &fdread, &fdwrite, &fdexcep, &maxfd);
+ mc = curl_multi_fdset(mcurl, &fdread, &fdwrite, &fdexcep, &maxfd);
- /* In a real-world program you OF COURSE check the return code of the
- function calls. On success, the value of maxfd is guaranteed to be
- greater or equal than -1. We call select(maxfd + 1, ...), specially in
- case of (maxfd == -1), we call select(0, ...), which is basically equal
- to sleep. */
+ if(mc != CURLM_OK)
+ {
+ fprintf(stderr, "curl_multi_fdset() failed, code %d.\n", mc);
+ break;
+ }
- rc = select(maxfd+1, &fdread, &fdwrite, &fdexcep, &timeout);
+ /* On success the value of maxfd is guaranteed to be >= -1. We call
+ select(maxfd + 1, ...); specially in case of (maxfd == -1) there are
+ no fds ready yet so we call select(0, ...) --or Sleep() on Windows--
+ to sleep 100ms, which is the minimum suggested value in the
+ curl_multi_fdset() doc. */
+
+ if(maxfd == -1) {
+#ifdef _WIN32
+ Sleep(100);
+ rc = 0;
+#else
+ /* Portable sleep for platforms other than Windows. */
+ struct timeval wait = { 0, 100 * 1000 }; /* 100ms */
+ rc = select(0, NULL, NULL, NULL, &wait);
+#endif
+ }
+ else {
+ /* Note that on some platforms 'timeout' may be modified by select().
+ If you need access to the original value save a copy beforehand. */
+ rc = select(maxfd+1, &fdread, &fdwrite, &fdexcep, &timeout);
+ }
- if (tvdiff(tvnow(), mp_start) > MULTI_PERFORM_HANG_TIMEOUT) {
- fprintf(stderr, "ABORTING TEST, since it seems "
- "that it would have run forever.\n");
+ if(tvdiff(tvnow(), mp_start) > MULTI_PERFORM_HANG_TIMEOUT) {
+ fprintf(stderr,
+ "ABORTING: Since it seems that we would have run forever.\n");
break;
}
switch(rc) {
- case -1:
- /* select error */
+ case -1: /* select error */
break;
- case 0:
- /* timeout, do something else */
- break;
- default:
- /* one or more of curl's file descriptors say there's data to read
- or write */
+ case 0: /* timeout */
+ default: /* action */
curl_multi_perform(mcurl, &still_running);
break;
}
}
- curl_slist_free_all(rcpt_list);
+ /* Free the list of recipients */
+ curl_slist_free_all(recipients);
+
+ /* Always cleanup */
curl_multi_remove_handle(mcurl, curl);
curl_multi_cleanup(mcurl);
curl_easy_cleanup(curl);
curl_global_cleanup();
+
return 0;
}
-
-
projects / platform / upstream / curl.git / blobdiff