Non-standard syntax use & to create a pointer. cURL

#ifndef MAIL_H_
#define MAIL_H_
 
#include <fstream>
#include <iostream>
#include <string>
 
struct SMTP
{
    std::string fin;
    std::string to;
    std::string from;
    std::string password;
    std::string inbox;
    std::string hostname;
    int timer = 0;
};
 
class Mail
{
private:
    struct upload_status{ int lines_read; };
    struct SMTP data;
    char payload_text[5][10000] =
    {
      "To: ",
      "From: ",
      "Subject: SMTP TLS example message\r\n",
      NULL
    };
    SMTP operator = (const SMTP conf);
    size_t payload_source(void* ptr, size_t size, size_t nmemb, void* userp);
    void send();
public:
    Mail(SMTP config);
    ~Mail();
    int loop();
};
 
#endif

#include "Mail.h"
 
#define CURL_STATICLIB
#include "curl/curl.h"
 
#pragma comment (lib, "curl/libcurl_a_debug.lib")
#pragma comment (lib, "ws2_32.lib")
#pragma comment (lib, "Crypt32.lib")
#pragma comment (lib, "advapi32.lib")
#pragma comment (lib, "Normaliz.lib")
#pragma comment (lib, "Wldap32.lib")
 
SMTP Mail::operator=(const SMTP config)
{
    SMTP out;
 
    out.fin = config.fin;
    out.from = config.from;
    out.hostname = config.hostname;
    out.inbox = config.inbox;
    out.password = config.password;
    out.timer = config.timer;
    out.to = config.to;
 
    return out;
}
Mail::Mail(SMTP config)
{   
    Mail::data = config;
    
    Mail::loop();
}
 
Mail::~Mail()
{
}
 
int Mail::loop()
{
    while(1)
    {
        Sleep(Mail::data.timer);
 
        Mail::send();
    }
}
 
void Mail::send()
{
    std::ifstream fin(Mail::data.fin);
    std::string text;
    text.assign((std::istreambuf_iterator<char>(fin)), std::istreambuf_iterator<char>());
    fin.close();
 
    strcat(Mail::payload_text[0], Mail::data.from.c_str());
    strcat(Mail::payload_text[0], "\r\n");
    strcat(Mail::payload_text[1], Mail::data.to.c_str());
    strcat(Mail::payload_text[1], "\r\n");
    memset(Mail::payload_text[3], 0, sizeof(Mail::payload_text[3]));
    strcpy(Mail::payload_text[3], text.c_str());
 
    CURL* curl;
    CURLcode res = CURLE_OK;
    struct curl_slist* recipients = NULL;
    struct upload_status upload_ctx;
 
    upload_ctx.lines_read = 0;
 
    curl = curl_easy_init();
    if (curl) {
        curl_easy_setopt(curl, CURLOPT_USERNAME, Mail::data.inbox);
        curl_easy_setopt(curl, CURLOPT_PASSWORD, Mail::data.password);
 
        curl_easy_setopt(curl, CURLOPT_URL, Mail::data.hostname);
 
        curl_easy_setopt(curl, CURLOPT_USE_SSL, (long)CURLUSESSL_ALL);
 
        curl_easy_setopt(curl, CURLOPT_MAIL_FROM, Mail::data.from);
 
        recipients = curl_slist_append(recipients, Mail::data.to.c_str());
        curl_easy_setopt(curl, CURLOPT_MAIL_RCPT, recipients);
 
        curl_easy_setopt(curl, CURLOPT_READFUNCTION, payload_source); // <--- Ошибка тут
        curl_easy_setopt(curl, CURLOPT_READDATA, &upload_ctx);
        curl_easy_setopt(curl, CURLOPT_UPLOAD, 1L);
 
        curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
 
        res = curl_easy_perform(curl);
 
        if (res != CURLE_OK)
            fprintf(stderr, "curl_easy_perform() failed: %s\n",
                curl_easy_strerror(res));
 
        curl_slist_free_all(recipients);
 
        curl_easy_cleanup(curl);
    }
}
 
size_t Mail::payload_source(void* ptr, size_t size, size_t nmemb, void* userp)
{
    struct upload_status* upload_ctx = (struct upload_status*)userp;
    const char* data;
 
    if ((size == 0) || (nmemb == 0) || ((size * nmemb) < 1)) {
        return 0;
    }
 
    data = Mail::payload_text[upload_ctx->lines_read];
 
    if (data) {
        size_t len = strlen(data);
        memcpy(ptr, data, len);
        upload_ctx->lines_read++;
 
        return len;
    }
}