This is macnsmtp.c in view mode; [Download] [Up]
/* macnsmtp.c -- simple async SMTP client
*/
/* (C) Copyright 1995 by Carnegie Mellon University
* All Rights Reserved.
*
* Permission to use, copy, modify, distribute, and sell this software
* and its documentation for any purpose is hereby granted without
* fee, provided that the above copyright notice appear in all copies
* and that both that copyright notice and this permission notice
* appear in supporting documentation, and that the name of Carnegie
* Mellon University not be used in advertising or publicity
* pertaining to distribution of the software without specific,
* written prior permission. Carnegie Mellon University makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied
* warranty.
*
* CARNEGIE MELLON UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO
* THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
* AND FITNESS, IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY BE LIABLE
* FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
* AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
* OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
* SOFTWARE.
*/
/* (C) Copyright 1994-1995 by Christopher J. Newman
* All Rights Reserved.
*
* Permission to use, copy, modify, distribute, and sell this software and its
* documentation for any purpose is hereby granted without fee, provided that
* the above copyright notice appear in all copies and that both that
* copyright notice and this permission notice appear in supporting
* documentation, and that the name of Christopher J. Newman not be used in
* advertising or publicity pertaining to distribution of the software without
* specific, written prior permission. Christopher J. Newman makes no
* representations about the suitability of this software for any purpose. It
* is provided "as is" without express or implied warranty.
*
* CHRISTOPHER J. NEWMAN DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT
* SHALL CHRISTOPHER J. NEWMAN BE LIABLE FOR ANY SPECIAL, INDIRECT OR
* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THIS SOFTWARE.
*
* Author: Christopher J. Newman
* Message: This is a nifty program.
*/
#include "macnapp.h"
#define SMTP_PORT 25
typedef struct {
na_win w;
void *context; /* user context */
short num, rcpt; /* recipient count (num), and sent (rcpt) */
na_smtpstat statf; /* callback */
na_tcp tcpid; /* TCP id */
short state; /* SMTP state (see below) */
short count; /* bytes used in linebuf */
short refnum; /* input file */
short crfound:1; /* found a CR in SMTP server data */
short crlf:1; /* found a CRLF in SMTP server data */
short crtrans:1; /* translate CR to CRLF in file */
long headsize; /* size of extra headers starting at data */
long fsize, fdone; /* file size & amount written */
long bufsize; /* usable buffer size */
Ptr buf; /* output buffer */
char linebuf[1024]; /* input line buffer */
char data[1]; /* header & envelope */
} na_smtpwin;
#define sw ((na_smtpwin *) w)
/* states: */
#define S_conn 0 /* connecting to server */
#define S_greet 1 /* waiting for greeting */
#define S_hello 2 /* waiting for local host lookup and HELO reply */
#define S_mailf 3 /* waiting for MAIL FROM reply */
#define S_rcpt 4 /* waiting for RCPT TO reply */
#define S_data 5 /* waiting for DATA continue reply */
#define S_send 6 /* transmitting data */
#define S_done 7 /* waiting for DATA success reply */
#define S_quit 8 /* waiting for QUIT reply */
#define S_wait 9 /* waiting for connection close */
#define S_close 10 /* closed */
/* generate and submit SMTP command line (put command & data together with CRLF ending)
* returns NATCPwrite result code
*/
static int SMTPsend(na_win *w, char *com, char *data)
{
char buf[512];
char *dest = buf;
int result = 0;
while ((*dest = *com) != '\0') ++dest, ++com;
if (data) {
while ((*dest = *data++) != '\0') ++dest;
if (com[-1] == '<') *dest++ = '>';
}
*dest++ = '\r';
*dest++ = '\n';
result = NATCPwrite(sw->tcpid, buf, dest - buf, -1);
return (result);
}
/* do final callback
*/
static void smtpclose(na_win *w, short code, short err, long size, char *data)
{
if (sw->state < S_wait) {
NATCPclose(sw->tcpid);
FSClose(sw->refnum);
sw->state = S_wait;
(*sw->statf)(sw->context, code, err, size, data);
}
}
/* TCP read/write callback
*/
static void readp(void *wh, na_tcp s, short status, long size, char *data)
{
na_win *w, **taskh;
char *dest;
short major, count, smtpcode;
/* make sure our SMTP task still exists */
for (taskh = NAtask; taskh && taskh != wh; taskh = (*taskh)->task);
if (!taskh) return;
/* handle TCP result */
w = NAlockWindow((na_win **) wh);
if (status == NATCP_connect) {
/* deal with new connection */
sw->state = S_greet;
} else if (status < 0) {
/* deal with TCP errors */
smtpclose(w, NASMTP_tcpfail, status, size, NULL);
if (status == NATCP_closed) sw->state = S_close;
} else if (status & NATCP_closing) {
/* deal with a closed connection */
if (sw->state < S_wait) {
smtpclose(w, NASMTP_conclosed, 0, 0, NULL);
}
} else if (status & NATCP_data) {
do {
/* buffer SMTP line */
dest = sw->linebuf + sw->count;
while (size && sw->count < sizeof (sw->linebuf)) {
--size, ++sw->count;
if (sw->crfound && *data == '\n') {
*--dest = '\0';
--sw->count;
++data;
sw->crfound = 0;
sw->crlf = 1;
break;
}
sw->crfound = (*dest++ = *data++) == '\r';
}
if (!sw->crlf) {
if (sw->count == sizeof (sw->linebuf)) {
sw->linebuf[sw->count - 1] = '\0';
smtpclose(w, NASMTP_badprot, 0, 0, sw->linebuf);
}
break;
}
sw->crlf = 0;
/* parse SMTP result code */
dest = sw->linebuf;
if (sw->count < 3 || !isdigit(dest[0])
|| !isdigit(dest[1]) || !isdigit(dest[2])) {
smtpclose(w, NASMTP_badprot, 0, 0, dest);
break;
}
sw->count = 0;
major = dest[0] - '0';
smtpcode = major * 100 + (dest[1] - '0') * 10 + (dest[2] - '0');
/* handle reply continuation */
if (dest[3] == '-') continue;
/* handle major errors */
if (major > 3) {
if (sw->state != S_rcpt) {
smtpclose(w, major == 4 ? NASMTP_temperr : NASMTP_permerr,
smtpcode, sw->state, dest + 3);
break;
}
(*sw->statf)(sw->context, NASMTP_badaddr, smtpcode, 0, sw->linebuf + 3);
}
dest = sw->data + sw->headsize;
/* state changes */
switch (sw->state) {
case S_greet:
if (sw->buf) {
SMTPsend(w, "HELO ", sw->buf);
if (sw->buf) DisposPtr(sw->buf);
}
sw->state = S_hello;
break;
case S_hello:
SMTPsend(w, "MAIL FROM:<", dest);
(*sw->statf)(sw->context, NASMTP_progress, 5, 0, 0);
sw->state = S_mailf;
break;
case S_mailf:
case S_rcpt:
count = ++sw->rcpt;
if (count < sw->num + 1) {
while (count--) {
while (*dest++);
}
SMTPsend(w, "RCPT TO:<", dest);
(*sw->statf)(sw->context, NASMTP_progress, 5 + 10 * sw->rcpt / sw->num, 0, 0);
} else {
sw->state = S_data;
SMTPsend(w, "DATA", 0);
(*sw->statf)(sw->context, NASMTP_progress, 20, 0, 0);
}
break;
case S_data:
if (major != 3) {
smtpclose(w, NASMTP_badprot, 0, 0, dest);
break;
}
sw->state = S_send;
if (sw->headsize) {
sw->buf = NewPtr(sw->bufsize = sw->headsize);
if (!sw->buf) {
smtpclose(w, NASMTP_nomem, 0, 0, NULL);
break;
}
memcpy(sw->buf, sw->data, sw->headsize);
}
case S_send:
/* NOTE: this case should never happen */
break;
case S_done:
sw->state = S_quit;
SMTPsend(w, "QUIT", NULL);
(*sw->statf)(sw->context, NASMTP_progress, 95, 0, 0);
break;
case S_quit:
smtpclose(w, NASMTP_completed, 0, 0, 0);
break;
}
} while (size);
}
NAunlockWindowh((na_win **) wh, w)
}
/* TCP gethost callback
*/
static void hostp(void *wh, na_tcp s, short status, long size, char *data)
{
na_win *w, **taskh;
/* make sure our task still exists */
for (taskh = NAtask; taskh && taskh != wh; taskh = (*taskh)->task);
if (!taskh) return;
/* store host/error */
w = NAlockWindow((na_win **) wh);
if (status == NATCP_connect) {
if (sw->state == S_hello) {
SMTPsend(w, "HELO ", data);
} else {
sw->buf = NewPtr(size + 1);
if (sw->buf == NULL) {
smtpclose(w, NASMTP_nomem, 0, 0, NULL);
} else {
memcpy(sw->buf, data, size + 1);
}
}
} else {
smtpclose(w, NASMTP_tcpfail, status, size, NULL);
}
NAunlockWindowh((na_win **) wh, w);
}
/* translate CR to CRLF
*/
static void crtocrlf(char *buf, long *size)
{
long crcount = 0;
char *src, *dst, *end = buf + *size;
for (src = buf; src < end; ++src) {
if (src[0] == '\r') ++crcount;
}
src = end - 1;
for (dst = src + crcount; dst > src; *dst-- = *src--) {
if (*src == '\r') *dst-- = '\n';
}
*size += crcount;
}
/* SMTP task
*/
static short taskp(na_win *w)
{
OSErr oserr;
if (sw->state == S_send || sw->state == S_done) {
/*XXX: could be generous with NewPtr() failure if a NATCPwritePending() */
if (!sw->bufsize) {
if ((sw->buf = NewPtr(8192)) == NULL) {
smtpclose(w, NASMTP_nomem, 0, 0, NULL);
return (NA_NOTPROCESSED);
}
sw->bufsize = sw->crtrans ? 4096 : 8192;
oserr = FSRead(sw->refnum, &sw->bufsize, sw->buf);
if (oserr != noErr && oserr != eofErr) sw->bufsize = 0;
if (!sw->bufsize) {
if (oserr == eofErr && sw->state == S_send) {
memcpy(sw->buf, "\r\n.\r\n", 5);
sw->bufsize = 5;
sw->state = S_done;
} else {
DisposPtr(sw->buf);
}
} else {
if (sw->crtrans) {
crtocrlf(sw->buf, &sw->bufsize);
}
(*sw->statf)(sw->context, NASMTP_progress, 20
+ 70 * (sw->fdone += sw->bufsize) / sw->fsize, 0, 0);
}
}
if (sw->bufsize && NATCPwrite(sw->tcpid, sw->buf, sw->bufsize, 1) == NATCP_data) {
sw->bufsize = 0;
}
}
return (sw->state == S_close ? NA_REQCLOSE : NA_NOTPROCESSED);
}
/* SMTP close procedure
* IMPORTANT: if the user quits during mail transmission, we want to
* warn the user that mail will be lost.
*/
static short closep(na_win *w)
{
if (sw->state < S_wait) {
/*XXX: put modal dialog here, allow abort of close */
if (sw->tcpid >= 0) NATCPclose(sw->tcpid);
FSClose(sw->refnum);
}
return (NA_CLOSED);
}
/* submit file to SMTP:
* creates SMTP task, initializes data, starts TCP connection
* copies from & dest addresses, so they don't need to persist
* task is not completed until statf() is called
*/
void NASMTPsubmit(na_smtpstat statf, char *server, FSSpec *fspec, Handle headers,
Handle envelope, short flags, void *context)
{
long size;
na_win **wh, *w;
char *src, *dst;
OSErr oserr;
/* create task */
size = sizeof (na_smtpwin);
if (headers) size += GetHandleSize(headers);
size += GetHandleSize(envelope);
wh = NAaddtask(taskp, size);
if (!wh) {
(*statf)(context, NASMTP_nomem, 0, 0, 0);
return;
}
/* init task */
w = NAlockWindow(wh);
w->type = NA_SMTPTYPE;
w->closep = closep;
sw->context = context;
sw->statf = statf;
if (headers && (sw->headsize = GetHandleSize(headers))) {
memcpy(sw->data, (char *) *headers, sw->headsize);
}
size = GetHandleSize(envelope);
sw->num = -1;
dst = sw->data + sw->headsize;
for (src = (char *) *envelope; size; --size) {
if ((*dst++ = *src++) == '\0') ++sw->num;
}
if (flags & NASMTP_crtrans) sw->crtrans = 1;
/* open file */
if ((oserr = HOpen(fspec->vRefNum, fspec->parID, fspec->name,
fsRdPerm, &sw->refnum)) != noErr) {
(*statf)(context, NASMTP_oserr, 0, oserr, 0);
NAcloseWindow(w, NA_CLOSED);
return;
}
GetEOF(sw->refnum, &sw->fsize);
/* open MacTCP */
sw->tcpid = NATCPopen(readp, (void *) wh, server, SMTP_PORT, 0);
if (sw->tcpid != -1) NATCPgethost(hostp, (void *) wh);
NAunlockWindowh(wh, w);
}
These are the contents of the former NiCE NeXT User Group NeXTSTEP/OpenStep software archive, currently hosted by Netfuture.ch.