Anope Stable Branch

git-svn-id: http://anope.svn.sourceforge.net/svnroot/anope/stable@1902 5417fbe8-f217-4b02-8779-1006273d7864

1 files changed, 604 insertions, 0 deletions

diff --git a/src/tools/anopesmtp.c b/src/tools/anopesmtp.c
new file mode 100644
index 000000000..4ff0c6fcf
--- /dev/null
+++ b/src/tools/anopesmtp.c
@@ -0,0 +1,604 @@
+/* smtp stuff handler for win32.
+ *
+ * (C) 2003-2008 Anope Team
+ * Contact us at info@anope.org
+ *
+ * Please read COPYING and README for furhter details.
+ *
+ * Based on the original code of Epona by Lara.
+ * Based on the original code of Services by Andy Church.
+ *
+ * Written by Dominick Meglio <codemastr@unrealircd.com>
+ * *nix port by Trystan Scott Lee <trystan@nomadirc.net>
+ *
+ */
+
+#include "smtp.h"
+
+static FILE *logfile;
+static int curday = 0;
+
+/*************************************************************************/
+
+#ifdef _WIN32
+int strcasecmp(const char *s1, const char *s2)
+{
+    register int c;
+
+    while ((c = tolower(*s1)) == tolower(*s2)) {
+        if (c == 0)
+            return 0;
+        s1++;
+        s2++;
+    }
+    if (c < tolower(*s2))
+        return -1;
+    return 1;
+}
+#endif
+
+static int get_logname(char *name, int count, struct tm *tm)
+{
+
+    char timestamp[32];
+
+    if (!tm) {
+        time_t t;
+
+        time(&t);
+        tm = localtime(&t);
+    }
+
+    strftime(timestamp, count, "%Y%m%d", tm);
+    snprintf(name, count, "logs/%s.%s", "anopesmtp", timestamp);
+    curday = tm->tm_yday;
+
+    return 1;
+}
+
+/*************************************************************************/
+
+/* Close the log file. */
+
+void close_log(void)
+{
+    if (!logfile)
+        return;
+    fclose(logfile);
+    logfile = NULL;
+}
+
+/*************************************************************************/
+
+static void remove_log(void)
+{
+    time_t t;
+    struct tm tm;
+
+    char name[PATH_MAX];
+
+    time(&t);
+    t -= (60 * 60 * 24 * 30);
+    tm = *localtime(&t);
+
+    if (!get_logname(name, sizeof(name), &tm))
+        return;
+    unlink(name);
+}
+
+/*************************************************************************/
+
+/* Open the log file.  Return -1 if the log file could not be opened, else
+ * return 0. */
+
+int open_log(void)
+{
+    char name[PATH_MAX];
+
+    if (logfile)
+        return 0;
+
+    if (!get_logname(name, sizeof(name), NULL))
+        return 0;
+    logfile = fopen(name, "a");
+
+    if (logfile)
+        setbuf(logfile, NULL);
+    return logfile != NULL ? 0 : -1;
+}
+
+/*************************************************************************/
+
+static void checkday(void)
+{
+    time_t t;
+    struct tm tm;
+
+    time(&t);
+    tm = *localtime(&t);
+
+    if (curday != tm.tm_yday) {
+        close_log();
+        remove_log();
+        open_log();
+    }
+}
+
+/*************************************************************************/
+
+/* Log stuff to the log file with a datestamp.  Note that errno is
+ * preserved by this routine and log_perror().
+ */
+
+void alog(const char *fmt, ...)
+{
+    va_list args;
+    time_t t;
+    struct tm tm;
+    char buf[256];
+    int errno_save = errno;
+
+    if (!smtp_debug) {
+        return;
+    }
+
+    checkday();
+
+    if (!fmt) {
+        return;
+    }
+
+    va_start(args, fmt);
+    time(&t);
+    tm = *localtime(&t);
+    strftime(buf, sizeof(buf) - 1, "[%b %d %H:%M:%S %Y] ", &tm);
+    if (logfile && args) {
+        fputs(buf, logfile);
+        vfprintf(logfile, fmt, args);
+        fputc('\n', logfile);
+    }
+    va_end(args);
+    errno = errno_save;
+}
+
+/*************************************************************************/
+
+/* Remove a trailing \r\n */
+char *strip(char *buf)
+{
+    char *c;
+    if ((c = strchr(buf, '\n')))
+        *c = 0;
+    if ((c = strchr(buf, '\r')))
+        *c = 0;
+    return buf;
+}
+
+/*************************************************************************/
+
+/* Convert a trailing \n to \r\n 
+ * The caller must free the allocated memory
+ */
+char *lftocrlf(char *buf)
+{
+    char *result = malloc(strlen(buf) + 2);
+    strip(buf);
+    strcpy(result, buf);
+    strcat(result, "\r\n");
+    return result;
+}
+
+/*************************************************************************/
+
+/* Add a header to the list */
+void smtp_add_header(char *header)
+{
+    struct smtp_header *head = malloc(sizeof(struct smtp_header));
+
+    head->header = lftocrlf(header);
+    head->next = NULL;
+
+    if (!mail.smtp_headers) {
+        mail.smtp_headers = head;
+    }
+    if (mail.smtp_headers_tail) {
+        mail.smtp_headers_tail->next = head;
+    }
+    mail.smtp_headers_tail = head;
+}
+
+/*************************************************************************/
+
+/* Is the buffer a header? */
+int smtp_is_header(char *buf)
+{
+    char *tmp = strchr(buf, ' ');
+
+    if (!tmp)
+        return 0;
+
+    if (*(tmp - 1) == ':')
+        return 1;
+    return 0;
+}
+
+/*************************************************************************/
+
+/* Parse a header into a name and value */
+void smtp_parse_header(char *buf, char **header, char **value)
+{
+    strip(buf);
+
+    *header = strtok(buf, " ");
+    *value = strtok(NULL, "");
+    if (*header)
+        (*header)[strlen(*header) - 1] = 0;
+}
+
+/*************************************************************************/
+
+/* Have we reached the end of input? */
+int smtp_is_end(char *buf)
+{
+    if (*buf == '.')
+        if (*(buf + 1) == '\r' || *(buf + 1) == '\n')
+            return 1;
+
+    return 0;
+}
+
+/*************************************************************************/
+
+/* Set who the email is from */
+void smtp_set_from(char *from)
+{
+    mail.from = strdup(from);
+}
+
+/*************************************************************************/
+
+/* Set who the email is to */
+void smtp_set_to(char *to)
+{
+    char *c;
+
+    if ((c = strrchr(to, '<')) && *(c + 1)) {
+        to = c + 1;
+        to[strlen(to) - 1] = 0;
+    }
+    mail.to = strdup(to);
+}
+
+/*************************************************************************/
+
+/* Add a line of body text */
+void smtp_add_body_line(char *line)
+{
+    struct smtp_body_line *body;
+
+    body = malloc(sizeof(struct smtp_body_line));
+
+    body->line = lftocrlf(line);
+    body->next = NULL;
+
+    if (!mail.smtp_body)
+        mail.smtp_body = body;
+    if (mail.smtp_body_tail)
+        mail.smtp_body_tail->next = body;
+    mail.smtp_body_tail = body;
+
+}
+
+/*************************************************************************/
+
+/* Establish a connection to the SMTP server */
+int smtp_connect(char *host, unsigned short port)
+{
+    struct sockaddr_in addr;
+
+    if ((mail.sock = socket(AF_INET, SOCK_STREAM, 0)) == SOCKET_ERROR)
+        return 0;
+
+    if ((addr.sin_addr.s_addr = inet_addr(host)) == INADDR_NONE) {
+        struct hostent *hent;
+        if (!(hent = gethostbyname(host)))
+            return 0;
+        memcpy(&addr.sin_addr, hent->h_addr, hent->h_length);
+    }
+    addr.sin_family = AF_INET;
+    addr.sin_port = htons(port ? port : 25);
+    if (connect(mail.sock, (struct sockaddr *) &addr, sizeof(struct sockaddr_in)) == SOCKET_ERROR) {
+        ano_sockclose(mail.sock);
+        return 0;
+    }
+
+    return 1;
+}
+
+/*************************************************************************/
+
+/* Send a line of text */
+int smtp_send(char *text)
+{
+    int result = ano_sockwrite(mail.sock, text, strlen(text));
+
+    alog("SMTP: sent %s",text);
+
+    if (result == SOCKET_ERROR)
+        ano_sockclose(mail.sock);
+
+    return result;
+}
+
+/*************************************************************************/
+
+/* Read a line of text */
+int smtp_read(char *buf, int len)
+{
+    int result;
+
+    memset(buf, 0, len);
+    result = ano_sockread(mail.sock, buf, len);
+
+    if (result == SOCKET_ERROR)
+        ano_sockclose(mail.sock);
+
+    return result;
+}
+
+/*************************************************************************/
+
+/* Retrieve a response code */
+int smtp_get_code(char *text)
+{
+    char *tmp = strtok(text, " ");
+
+    if (!tmp)
+        return 0;
+
+    return atol(tmp);
+}
+
+/*************************************************************************/
+
+/* Send the email */
+int smtp_send_email()
+{
+    char buf[1024];
+    struct smtp_header *head;
+    struct smtp_body_line *body;
+    int code;
+    int skip_done = 0;
+
+    if (!smtp_read(buf, 1024)) {
+	    alog("SMTP: error reading buffer");
+        return 0;
+    }
+
+    code = smtp_get_code(buf);
+    if (code != 220) {
+	    alog("SMTP: error expected code 220 got %d",code);
+        return 0;
+    }
+
+    if (!smtp_send("HELO anope\r\n")) {
+	    alog("SMTP: error writting to socket");
+        return 0;
+    } 
+
+    if (!smtp_read(buf, 1024)) {
+	alog("SMTP: error reading buffer");
+        return 0;
+    }
+
+    code = smtp_get_code(buf);
+    if (code != 250) {
+	    alog("SMTP: error expected code 250 got %d",code);
+        return 0;
+    }
+
+    strcpy(buf, "MAIL FROM: <");
+    strcat(buf, mail.from);
+    strcat(buf, ">\r\n");
+
+    if (!smtp_send(buf)) {
+	    alog("SMTP: error writting to socket");
+        return 0;
+    }
+
+    if (!smtp_read(buf, 1024)) {
+	    alog("SMTP: error reading buffer");
+        return 0;
+    }
+
+    code = smtp_get_code(buf);
+    if (code != 250)
+        return 0;
+
+    strcpy(buf, "RCPT TO: <");
+    strcat(buf, mail.to);
+    strcat(buf, ">\r\n");
+
+    if (!smtp_send(buf)) {
+	    alog("SMTP: error writting to socket");
+        return 0;
+    }
+
+    if (!smtp_read(buf, 1024)) {
+	    alog("SMTP: error reading buffer");
+        return 0;
+    }
+
+    code = smtp_get_code(buf);
+    if (smtp_get_code(buf) != 250) {
+	    alog("SMTP: error expected code 250 got %d",code);
+        return 0;
+    }
+
+    if (!smtp_send("DATA\r\n")) {
+	    alog("SMTP: error writting to socket");
+        return 0;
+    }
+
+    if (!smtp_read(buf, 1024)) {
+	    alog("SMTP: error reading buffer");
+        return 0;
+    }
+
+    code = smtp_get_code(buf);
+    if (code != 354) {
+	    alog("SMTP: error expected code 354 got %d",code);
+        return 0;
+    }
+
+    for (head = mail.smtp_headers; head; head = head->next) {
+        if (!smtp_send(head->header)) {
+	        alog("SMTP: error writting to socket");
+            return 0;
+ 	    }
+    }
+
+    if (!smtp_send("\r\n")) {
+	    alog("SMTP: error writting to socket");
+        return 0;
+    }
+
+    for (body = mail.smtp_body; body; body = body->next) {
+        if (skip_done) {
+            if (!smtp_send(body->line)) {
+	            alog("SMTP: error writting to socket");
+                return 0;
+            }
+        } else {
+            skip_done = 1;
+        }
+    }
+
+    if (!smtp_send("\r\n.\r\n")) {
+	    alog("SMTP: error writting to socket");
+        return 0;
+    }
+
+    return 1;
+}
+
+/*************************************************************************/
+
+void smtp_disconnect()
+{
+    smtp_send("QUIT\r\n");
+    ano_sockclose(mail.sock);
+}
+
+/*************************************************************************/
+
+void mail_cleanup()
+{
+	struct smtp_header *headers, *nexth;
+	struct smtp_body_line *body, *nextb;
+	
+	if (mail.from)
+		free(mail.from);
+	if (mail.to)
+		free(mail.to);
+	
+	headers = mail.smtp_headers;
+	while (headers) {
+		nexth = headers->next;
+		free(headers->header);
+		free(headers);
+		headers = nexth;
+	}
+	
+	body = mail.smtp_body;
+	while (body) {
+		nextb = body->next;
+		free(body->line);
+		free(body);
+		body = nextb;
+	}
+}
+
+/*************************************************************************/
+
+int main(int argc, char *argv[])
+{
+    char buf[8192];
+/*	These are somehow unused - why are they here? -GD
+
+    struct smtp_body_line *b;
+    struct smtp_header *h;
+*/
+    int headers_done = 0;
+/* Win32 stuff */
+#ifdef _WIN32
+    WSADATA wsa;
+#endif
+    char *server, *aport;
+    short port;
+
+    if (argc == 1)
+        return 0;
+
+    server = strtok(argv[1], ":");
+    if ((aport = strtok(NULL, ""))) {
+        port = atoi(aport);
+    } else {
+        port = 25;
+    }
+
+   if (!server) {
+        alog("No Server");
+	/* Bad, bad, bad. This was a eturn from main with no value! -GD */
+        return 0;
+    } else {
+        alog("SMTP: server %s port %d",server,port);
+    }
+
+    memset(&mail, 0, sizeof(mail));
+
+/* The WSAStartup function initiates use of WS2_32.DLL by a process. */
+/* guessing we can skip it under *nix */
+#ifdef _WIN32
+    if (WSAStartup(MAKEWORD(1, 1), &wsa) != 0)
+        return 0;
+#endif
+
+    /* Read the message and parse it */
+    while (fgets(buf, 8192, stdin)) {
+        if (smtp_is_header(buf) && !headers_done) {
+            char *header, *value;
+            smtp_add_header(buf);
+            smtp_parse_header(buf, &header, &value);
+            if (!strcasecmp(header, "from")) {
+		        alog("SMTP: from: %s",value);
+                smtp_set_from(value);
+            } else if (!strcasecmp(header, "to")) {
+        		alog("SMTP: to: %s",value);
+                smtp_set_to(value);
+            } else if (smtp_is_end(buf)) {
+                break;
+            } else {
+                headers_done = 1;
+                smtp_add_body_line(buf);
+            }
+        } else {
+                smtp_add_body_line(buf);
+        }
+    }
+
+    if (!smtp_connect(server, port)) {
+	    alog("SMTP: failed to connect to %s:%d",server, port);
+		mail_cleanup();
+        return 0;
+    }
+    if (!smtp_send_email()) {
+	    alog("SMTP: error during sending of mail");
+		mail_cleanup();
+        return 0;
+    }
+    smtp_disconnect();
+	mail_cleanup();
+	
+    return 1;
+}