#include "php.h"
#include <stdio.h>
#include <stdlib.h>
#ifndef NETWARE
#include <winsock2.h>
#include "time.h"
# include <Ws2tcpip.h>
#else
#include <netware/sendmail_nw.h>
#endif
#include <string.h>
#include <math.h>
#ifndef NETWARE
#include <malloc.h>
#include <memory.h>
#include <winbase.h>
#endif
#include "sendmail.h"
#include "php_ini.h"
#include "inet.h"
#include "php_win32_globals.h"
#if HAVE_PCRE || HAVE_BUNDLED_PCRE
#include "ext/pcre/php_pcre.h"
#endif
#include "ext/standard/php_string.h"
#include "ext/date/php_date.h"
#define SENDMAIL_DEBUG 0
#define SMTP_ERROR_RESPONSE_SPEC "SMTP server response: %s"
#define SMTP_ERROR_RESPONSE(response) { \
if (response && error_message) { \
if (NULL != (*error_message = ecalloc(1, sizeof(SMTP_ERROR_RESPONSE_SPEC) + strlen(response)))) { \
snprintf(*error_message, sizeof(SMTP_ERROR_RESPONSE_SPEC) + strlen(response), SMTP_ERROR_RESPONSE_SPEC, response); \
} \
efree(response); \
} \
}
#define SMTP_SKIP_SPACE(str) { while (isspace(*str)) { str++; } }
char seps[] = " ,\t\n";
#ifndef NETWARE
char *php_mailer = "PHP 7 WIN32";
#else
char *php_mailer = "PHP 7 NetWare";
#endif
static char *ErrorMessages[] =
{
{"Success"},
{"Bad arguments from form"},
{"Unable to open temporary mailfile for read"},
{"Failed to Start Sockets"},
{"Failed to Resolve Host"},
{"Failed to obtain socket handle"},
{"Failed to connect to mailserver, verify your \"SMTP\" setting in php.ini"},
{"Failed to Send"},
{"Failed to Receive"},
{"Server Error"},
{"Failed to resolve the host IP name"},
{"Out of memory"},
{"Unknown error"},
{"Bad Message Contents"},
{"Bad Message Subject"},
{"Bad Message destination"},
{"Bad Message Return Path"},
{"Bad Mail Host"},
{"Bad Message File"},
{"\"sendmail_from\" not set in php.ini or custom \"From:\" header missing"},
{"Mailserver rejected our \"sendmail_from\" setting"},
{"Error while trimming mail header with PCRE, please file a bug report at http://bugs.php.net/"}
};
#define PHP_WIN32_MAIL_UNIFY_PATTERN "/(\r\n?)|\n/"
#define PHP_WIN32_MAIL_UNIFY_REPLACE "\r\n"
#define PHP_WIN32_MAIL_RMVDBL_PATTERN "/^\r\n|(\r\n)+$/m"
#define PHP_WIN32_MAIL_RMVDBL_REPLACE ""
#define PHP_WIN32_MAIL_DOT_PATTERN "\n."
#define PHP_WIN32_MAIL_DOT_REPLACE "\n.."
static zend_string *php_win32_mail_trim_header(char *header)
{
#if HAVE_PCRE || HAVE_BUNDLED_PCRE
zend_string *result, *result2;
zval replace;
zend_string *regex;
if (!header) {
return NULL;
}
ZVAL_STRINGL(&replace, PHP_WIN32_MAIL_UNIFY_REPLACE, strlen(PHP_WIN32_MAIL_UNIFY_REPLACE));
regex = zend_string_init(PHP_WIN32_MAIL_UNIFY_PATTERN, sizeof(PHP_WIN32_MAIL_UNIFY_PATTERN)-1, 0);
result = php_pcre_replace(regex,
NULL, header, (int)strlen(header),
&replace,
0,
-1,
NULL);
zval_ptr_dtor(&replace);
zend_string_release(regex);
if (NULL == result) {
return NULL;
}
ZVAL_STRING(&replace, PHP_WIN32_MAIL_RMVDBL_PATTERN);
regex = zend_string_init(PHP_WIN32_MAIL_RMVDBL_PATTERN, sizeof(PHP_WIN32_MAIL_RMVDBL_PATTERN)-1, 0);
result2 = php_pcre_replace(regex,
result, ZSTR_VAL(result), (int)ZSTR_LEN(result),
&replace,
0,
-1,
NULL);
zval_ptr_dtor(&replace);
zend_string_release(regex);
zend_string_release(result);
return result2;
#else
return estrdup(header);
#endif
}
PHPAPI int TSendMail(char *host, int *error, char **error_message,
char *headers, char *Subject, char *mailTo, char *data,
char *mailCc, char *mailBcc, char *mailRPath)
{
int ret;
char *RPath = NULL;
zend_string *headers_lc = NULL, *headers_trim = NULL;
char *pos1 = NULL, *pos2 = NULL;
if (host == NULL) {
*error = BAD_MAIL_HOST;
return FAILURE;
} else if (strlen(host) >= HOST_NAME_LEN) {
*error = BAD_MAIL_HOST;
return FAILURE;
} else {
strcpy(PW32G(mail_host), host);
}
if (headers) {
char *pos = NULL;
if (NULL == (headers_trim = php_win32_mail_trim_header(headers))) {
*error = W32_SM_PCRE_ERROR;
return FAILURE;
}
headers_lc = zend_string_tolower(headers_trim);
}
if (mailRPath && *mailRPath) {
RPath = estrdup(mailRPath);
} else if (INI_STR("sendmail_from")) {
RPath = estrdup(INI_STR("sendmail_from"));
} else if (headers_lc) {
int found = 0;
char *lookup = ZSTR_VAL(headers_lc);
while (lookup) {
pos1 = strstr(lookup, "from:");
if (!pos1) {
break;
} else if (pos1 != ZSTR_VAL(headers_lc) && *(pos1-1) != '\n') {
if (strlen(pos1) >= sizeof("from:")) {
lookup = pos1 + sizeof("from:");
continue;
} else {
break;
}
}
found = 1;
pos1 = headers + (pos1 - lookup) + 5;
if (NULL == (pos2 = strstr(pos1, "\r\n"))) {
RPath = estrndup(pos1, strlen(pos1));
} else {
RPath = estrndup(pos1, pos2 - pos1);
}
break;
}
if (!found) {
if (headers_lc) {
zend_string_free(headers_lc);
}
*error = W32_SM_SENDMAIL_FROM_NOT_SET;
return FAILURE;
}
}
*error = MailConnect();
if (*error != 0) {
if (RPath) {
efree(RPath);
}
if (headers) {
zend_string_free(headers_trim);
zend_string_free(headers_lc);
}
if (NULL == (*error_message = ecalloc(1, HOST_NAME_LEN + 128))) {
return FAILURE;
}
snprintf(*error_message, HOST_NAME_LEN + 128,
"Failed to connect to mailserver at \"%s\" port %d, verify your \"SMTP\" "
"and \"smtp_port\" setting in php.ini or use ini_set()",
PW32G(mail_host), !INI_INT("smtp_port") ? 25 : INI_INT("smtp_port"));
return FAILURE;
} else {
ret = SendText(RPath, Subject, mailTo, mailCc, mailBcc, data, headers ? ZSTR_VAL(headers_trim) : NULL, headers ? ZSTR_VAL(headers_lc) : NULL, error_message);
TSMClose();
if (RPath) {
efree(RPath);
}
if (headers) {
zend_string_free(headers_trim);
zend_string_free(headers_lc);
}
if (ret != SUCCESS) {
*error = ret;
return FAILURE;
}
return SUCCESS;
}
}
PHPAPI void TSMClose()
{
Post("QUIT\r\n");
Ack(NULL);
shutdown(PW32G(mail_socket), 0);
closesocket(PW32G(mail_socket));
}
PHPAPI char *GetSMErrorText(int index)
{
if (MIN_ERROR_INDEX <= index && index < MAX_ERROR_INDEX) {
return (ErrorMessages[index]);
} else {
return (ErrorMessages[UNKNOWN_ERROR]);
}
}
PHPAPI zend_string *php_str_to_str(char *haystack, size_t length, char *needle,
size_t needle_len, char *str, size_t str_len);
static int SendText(char *RPath, char *Subject, char *mailTo, char *mailCc, char *mailBcc, char *data,
char *headers, char *headers_lc, char **error_message)
{
int res;
char *p;
char *tempMailTo, *token, *pos1, *pos2;
char *server_response = NULL;
char *stripped_header = NULL;
zend_string *data_cln;
if (data == NULL)
return (BAD_MSG_CONTENTS);
if (mailTo == NULL)
return (BAD_MSG_DESTINATION);
if (RPath == NULL)
return (BAD_MSG_RPATH);
snprintf(PW32G(mail_buffer), sizeof(PW32G(mail_buffer)), "HELO %s\r\n", PW32G(mail_local_host));
if ((res = Post(PW32G(mail_buffer))) != SUCCESS) {
int err = MailConnect();
if (0 != err) {
return (FAILED_TO_SEND);
}
if ((res = Post(PW32G(mail_buffer))) != SUCCESS) {
return (res);
}
}
if ((res = Ack(&server_response)) != SUCCESS) {
SMTP_ERROR_RESPONSE(server_response);
return (res);
}
SMTP_SKIP_SPACE(RPath);
FormatEmailAddress(PW32G(mail_buffer), RPath, "MAIL FROM:<%s>\r\n");
if ((res = Post(PW32G(mail_buffer))) != SUCCESS) {
return (res);
}
if ((res = Ack(&server_response)) != SUCCESS) {
SMTP_ERROR_RESPONSE(server_response);
return W32_SM_SENDMAIL_FROM_MALFORMED;
}
tempMailTo = estrdup(mailTo);
token = strtok(tempMailTo, ",");
while (token != NULL)
{
SMTP_SKIP_SPACE(token);
FormatEmailAddress(PW32G(mail_buffer), token, "RCPT TO:<%s>\r\n");
if ((res = Post(PW32G(mail_buffer))) != SUCCESS) {
efree(tempMailTo);
return (res);
}
if ((res = Ack(&server_response)) != SUCCESS) {
SMTP_ERROR_RESPONSE(server_response);
efree(tempMailTo);
return (res);
}
token = strtok(NULL, ",");
}
efree(tempMailTo);
if (mailCc && *mailCc) {
tempMailTo = estrdup(mailCc);
token = strtok(tempMailTo, ",");
while (token != NULL)
{
SMTP_SKIP_SPACE(token);
FormatEmailAddress(PW32G(mail_buffer), token, "RCPT TO:<%s>\r\n");
if ((res = Post(PW32G(mail_buffer))) != SUCCESS) {
efree(tempMailTo);
return (res);
}
if ((res = Ack(&server_response)) != SUCCESS) {
SMTP_ERROR_RESPONSE(server_response);
efree(tempMailTo);
return (res);
}
token = strtok(NULL, ",");
}
efree(tempMailTo);
}
else if (headers && (pos1 = strstr(headers_lc, "cc:")) && ((pos1 == headers_lc) || (*(pos1-1) == '\n'))) {
pos1 = headers + (pos1 - headers_lc) + 3;
if (NULL == (pos2 = strstr(pos1, "\r\n"))) {
tempMailTo = estrndup(pos1, strlen(pos1));
} else {
tempMailTo = estrndup(pos1, pos2 - pos1);
}
token = strtok(tempMailTo, ",");
while (token != NULL)
{
SMTP_SKIP_SPACE(token);
FormatEmailAddress(PW32G(mail_buffer), token, "RCPT TO:<%s>\r\n");
if ((res = Post(PW32G(mail_buffer))) != SUCCESS) {
efree(tempMailTo);
return (res);
}
if ((res = Ack(&server_response)) != SUCCESS) {
SMTP_ERROR_RESPONSE(server_response);
efree(tempMailTo);
return (res);
}
token = strtok(NULL, ",");
}
efree(tempMailTo);
}
if (mailBcc && *mailBcc) {
tempMailTo = estrdup(mailBcc);
token = strtok(tempMailTo, ",");
while (token != NULL)
{
SMTP_SKIP_SPACE(token);
FormatEmailAddress(PW32G(mail_buffer), token, "RCPT TO:<%s>\r\n");
if ((res = Post(PW32G(mail_buffer))) != SUCCESS) {
efree(tempMailTo);
return (res);
}
if ((res = Ack(&server_response)) != SUCCESS) {
SMTP_ERROR_RESPONSE(server_response);
efree(tempMailTo);
return (res);
}
token = strtok(NULL, ",");
}
efree(tempMailTo);
}
else if (headers) {
if ((pos1 = strstr(headers_lc, "bcc:")) && (pos1 == headers_lc || *(pos1-1) == '\n')) {
pos1 = headers + (pos1 - headers_lc) + 4;
if (NULL == (pos2 = strstr(pos1, "\r\n"))) {
tempMailTo = estrndup(pos1, strlen(pos1));
pos2 = pos1;
} else {
tempMailTo = estrndup(pos1, pos2 - pos1);
}
token = strtok(tempMailTo, ",");
while (token != NULL)
{
SMTP_SKIP_SPACE(token);
FormatEmailAddress(PW32G(mail_buffer), token, "RCPT TO:<%s>\r\n");
if ((res = Post(PW32G(mail_buffer))) != SUCCESS) {
efree(tempMailTo);
return (res);
}
if ((res = Ack(&server_response)) != SUCCESS) {
SMTP_ERROR_RESPONSE(server_response);
efree(tempMailTo);
return (res);
}
token = strtok(NULL, ",");
}
efree(tempMailTo);
if (NULL == (stripped_header = ecalloc(1, strlen(headers)))) {
return OUT_OF_MEMORY;
}
memcpy(stripped_header, headers, pos1 - headers - 4);
if (pos1 != pos2) {
memcpy(stripped_header + (pos1 - headers - 4), pos2 + 2, strlen(pos2) - 2);
}
}
}
if (headers && !stripped_header) {
if (NULL == (stripped_header = estrndup(headers, strlen(headers)))) {
return OUT_OF_MEMORY;
}
}
if ((res = Post("DATA\r\n")) != SUCCESS) {
if (stripped_header) {
efree(stripped_header);
}
return (res);
}
if ((res = Ack(&server_response)) != SUCCESS) {
SMTP_ERROR_RESPONSE(server_response);
if (stripped_header) {
efree(stripped_header);
}
return (res);
}
if (Subject == NULL) {
res = PostHeader(RPath, "No Subject", mailTo, stripped_header);
} else {
res = PostHeader(RPath, Subject, mailTo, stripped_header);
}
if (stripped_header) {
efree(stripped_header);
}
if (res != SUCCESS) {
return (res);
}
data_cln = php_str_to_str(data, strlen(data), PHP_WIN32_MAIL_DOT_PATTERN, sizeof(PHP_WIN32_MAIL_DOT_PATTERN) - 1,
PHP_WIN32_MAIL_DOT_REPLACE, sizeof(PHP_WIN32_MAIL_DOT_REPLACE) - 1);
if (!data_cln) {
data_cln = ZSTR_EMPTY_ALLOC();
}
{
char c, *e2, *e = ZSTR_VAL(data_cln) + ZSTR_LEN(data_cln);
p = ZSTR_VAL(data_cln);
while (e - p > 1024) {
e2 = p + 1024;
c = *e2;
*e2 = '\0';
if ((res = Post(p)) != SUCCESS) {
zend_string_free(data_cln);
return(res);
}
*e2 = c;
p = e2;
}
if ((res = Post(p)) != SUCCESS) {
zend_string_free(data_cln);
return(res);
}
}
zend_string_free(data_cln);
if ((res = Post("\r\n.\r\n")) != SUCCESS)
return (res);
if ((res = Ack(&server_response)) != SUCCESS) {
SMTP_ERROR_RESPONSE(server_response);
return (res);
}
return (SUCCESS);
}
static int addToHeader(char **header_buffer, const char *specifier, char *string)
{
if (NULL == (*header_buffer = erealloc(*header_buffer, strlen(*header_buffer) + strlen(specifier) + strlen(string) + 1))) {
return 0;
}
sprintf(*header_buffer + strlen(*header_buffer), specifier, string);
return 1;
}
static int PostHeader(char *RPath, char *Subject, char *mailTo, char *xheaders)
{
int res;
char *header_buffer;
char *headers_lc = NULL;
size_t i;
if (xheaders) {
size_t headers_lc_len;
if (NULL == (headers_lc = estrdup(xheaders))) {
return OUT_OF_MEMORY;
}
headers_lc_len = strlen(headers_lc);
for (i = 0; i < headers_lc_len; i++) {
headers_lc[i] = tolower(headers_lc[i]);
}
}
header_buffer = ecalloc(1, MAIL_BUFFER_SIZE);
if (!xheaders || !strstr(headers_lc, "date:")) {
time_t tNow = time(NULL);
zend_string *dt = php_format_date("r", 1, tNow, 1);
snprintf(header_buffer, MAIL_BUFFER_SIZE, "Date: %s\r\n", ZSTR_VAL(dt));
zend_string_free(dt);
}
if (!headers_lc || !strstr(headers_lc, "from:")) {
if (!addToHeader(&header_buffer, "From: %s\r\n", RPath)) {
goto PostHeader_outofmem;
}
}
if (!addToHeader(&header_buffer, "Subject: %s\r\n", Subject)) {
goto PostHeader_outofmem;
}
if ((headers_lc && (!strstr(headers_lc, "\r\nto:") && (strncmp(headers_lc, "to:", 3) != 0))) || !headers_lc) {
if (!addToHeader(&header_buffer, "To: %s\r\n", mailTo)) {
goto PostHeader_outofmem;
}
}
if (xheaders) {
if (!addToHeader(&header_buffer, "%s\r\n", xheaders)) {
goto PostHeader_outofmem;
}
}
if (headers_lc) {
efree(headers_lc);
}
if ((res = Post(header_buffer)) != SUCCESS) {
efree(header_buffer);
return (res);
}
efree(header_buffer);
if ((res = Post("\r\n")) != SUCCESS) {
return (res);
}
return (SUCCESS);
PostHeader_outofmem:
if (headers_lc) {
efree(headers_lc);
}
return OUT_OF_MEMORY;
}
static int MailConnect()
{
int res, namelen;
short portnum;
struct hostent *ent;
IN_ADDR addr;
#ifdef HAVE_IPV6
IN6_ADDR addr6;
#endif
SOCKADDR_IN sock_in;
#if SENDMAIL_DEBUG
return 0;
#endif
if ((PW32G(mail_socket) = socket(PF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET) {
return (FAILED_TO_OBTAIN_SOCKET_HANDLE);
}
if (gethostname(PW32G(mail_local_host), HOST_NAME_LEN)) {
closesocket(PW32G(mail_socket));
return (FAILED_TO_GET_HOSTNAME);
}
ent = gethostbyname(PW32G(mail_local_host));
if (!ent) {
closesocket(PW32G(mail_socket));
return (FAILED_TO_GET_HOSTNAME);
}
namelen = (int)strlen(ent->h_name);
#ifdef HAVE_IPV6
if (inet_pton(AF_INET, ent->h_name, &addr) == 1 || inet_pton(AF_INET6, ent->h_name, &addr6) == 1)
#else
if (inet_pton(AF_INET, ent->h_name, &addr) == 1)
#endif
{
if (namelen + 2 >= HOST_NAME_LEN) {
closesocket(PW32G(mail_socket));
return (FAILED_TO_GET_HOSTNAME);
}
strcpy(PW32G(mail_local_host), "[");
strcpy(PW32G(mail_local_host) + 1, ent->h_name);
strcpy(PW32G(mail_local_host) + namelen + 1, "]");
} else {
if (namelen >= HOST_NAME_LEN) {
closesocket(PW32G(mail_socket));
return (FAILED_TO_GET_HOSTNAME);
}
strcpy(PW32G(mail_local_host), ent->h_name);
}
portnum = (short) INI_INT("smtp_port");
if (!portnum) {
portnum = 25;
}
sock_in.sin_family = AF_INET;
sock_in.sin_port = htons(portnum);
sock_in.sin_addr.S_un.S_addr = GetAddr(PW32G(mail_host));
if (connect(PW32G(mail_socket), (LPSOCKADDR) & sock_in, sizeof(sock_in))) {
closesocket(PW32G(mail_socket));
return (FAILED_TO_CONNECT);
}
res = Ack(NULL);
return (res);
}
static int Post(LPCSTR msg)
{
int len = (int)strlen(msg);
int slen;
int index = 0;
#if SENDMAIL_DEBUG
if (msg)
printf("POST: '%s'\n", msg);
return (SUCCESS);
#endif
while (len > 0) {
if ((slen = send(PW32G(mail_socket), msg + index, len, 0)) < 1)
return (FAILED_TO_SEND);
len -= slen;
index += slen;
}
return (SUCCESS);
}
static int Ack(char **server_response)
{
ZEND_TLS char buf[MAIL_BUFFER_SIZE];
int rlen;
int Index = 0;
int Received = 0;
#if SENDMAIL_DEBUG
return (SUCCESS);
#endif
again:
if ((rlen = recv(PW32G(mail_socket), buf + Index, ((MAIL_BUFFER_SIZE) - 1) - Received, 0)) < 1) {
return (FAILED_TO_RECEIVE);
}
Received += rlen;
buf[Received] = 0;
Index += rlen;
if (Received < 5 || buf[Received - 1] != '\n' || buf[Received - 2] != '\r') {
goto again;
}
if (buf[0] > '3') {
if (server_response) {
int dec = 0;
if (Received > 2) {
if (buf[Received-1] == '\n' || buf[Received-1] == '\r') {
dec++;
if (buf[Received-2] == '\r' || buf[Received-2] == '\n') {
dec++;
}
}
}
*server_response = estrndup(buf, Received - dec);
}
return (SMTP_SERVER_ERROR);
}
return (SUCCESS);
}
static unsigned long GetAddr(LPSTR szHost)
{
LPHOSTENT lpstHost;
u_long lAddr = INADDR_ANY;
if (*szHost) {
lAddr = inet_addr(szHost);
if ((lAddr == INADDR_NONE) && (strcmp(szHost, "255.255.255.255"))) {
lpstHost = gethostbyname(szHost);
if (lpstHost) {
lAddr = *((u_long FAR *) (lpstHost->h_addr));
} else {
lAddr = INADDR_ANY;
}
}
}
return (lAddr);
}
static int FormatEmailAddress(char* Buf, char* EmailAddress, char* FormatString) {
char *tmpAddress1, *tmpAddress2;
int result;
if( (tmpAddress1 = strchr(EmailAddress, '<')) && (tmpAddress2 = strchr(tmpAddress1, '>')) ) {
*tmpAddress2 = 0; result = snprintf(Buf, MAIL_BUFFER_SIZE, FormatString , tmpAddress1+1);
*tmpAddress2 = '>'; return result;
}
return snprintf(Buf, MAIL_BUFFER_SIZE , FormatString , EmailAddress );
}