mirror/winamp
1
0
Fork 0
mirror of https://github.com/WinampDesktop/winamp.git synced 2024-09-24 15:54:12 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
winamp/Src/Plugins/DSP/sc_serv3/auth.cpp
Jef 0954e03b3a Initial community commit
2024-09-24 14:54:57 +02:00

434 lines
13 KiB
C++
Raw Permalink Blame History

/* auth.cpp routines for authenticating client details with external server */
#include <curl/curl.h>
#include <list>
#include "protocol_shoutcastClient.h"
#include "uvox2Common.h"
#include "webClient.h"
#include "auth.h"
#include "bandwidth.h"
#include "file/fileUtils.h"
#include "services/stdServiceImpl.h"
#define MAX_AUTH_THREADS 20
#define AMNT_ALLOWED_BEFORE_SKIPPING 1000
#define LOGNAME "[AUTH] "
#define DEBUG_LOG(...) do { if (gOptions.authDebug()) DLOG(__VA_ARGS__); } while(0)
extern int xferinfo(void *clientp, curl_off_t dltotal, curl_off_t dlnow, curl_off_t ultotal, curl_off_t ulnow);
namespace auth
{
using namespace std;
using namespace uniString;
using namespace stringUtil;
class authService
{
public:
time_t restart_time;
utf8 main_post;
list<auth_info*> clients;
CURL *m_curl;
bool in_use;
authService();
~authService();
static THREAD_FUNC process(void *arg);
friend void schedule(auth_info *info);
friend void init();
};
list<auth_info*> g_queue;
AOL_namespace::mutex g_qMutex;
authService * g_services = 0;
utf8 g_authURL = DNAS_AUTH_URL;
#ifdef CURLOPT_PASSWDFUNCTION
/* make sure that prompting at the console does not occur */
static int my_getpass(void *client, char *prompt, char *buffer, int buflen)
{
buffer[0] = '\0';
return 0;
}
#endif
static int handle_returned_header(void *ptr, size_t size, size_t nmemb, void *stream)
{
auth_info *info = reinterpret_cast<auth_info*>(stream);
if (info)
{
utf8 line((char*)ptr);
if (!line.empty())
{
line = stripWhitespace(line);
if (!line.empty())
{
// skip over the initial HTTP header and just look at key pairs
utf8::size_type pos = line.find(utf8(":"));
if (pos != utf8::npos)
{
utf8 key = toLower(stripWhitespace(line.substr(0,pos)));
utf8 value = stripWhitespace(line.substr(pos+1));
if (!key.empty())
{
DEBUG_LOG("[AUTH sid=" + tos(info->sid) + "] Auth Header [" + key + ":" + value + "]");
if (key == "shoutcast-auth-user")
{
if (value == "withintro")
{
info->has_intro = true;
}
info->authenticated = true;
info->valid_response = true;
}
else if (key == "advert-group")
{
info->group = atoi(value.hideAsString().c_str());
#if defined(_DEBUG) || defined(DEBUG)
if (info->group == 1729)
{
info->group = 501;
}
#endif
info->valid_response = true;
}
}
}
}
}
}
int amount = (int)(size * nmemb);
bandWidth::updateAmount(bandWidth::AUTH_AND_METRICS, amount);
return amount;
}
static int handle_returned_data(void *ptr, size_t size, size_t nmemb, void *stream)
{
auth_info *info = reinterpret_cast<auth_info*>(stream);
if (info)
{
// cap any intro content to a few meg
if (info->has_intro && ((int)info->content.size() <= gOptions.maxSpecialFileSize()))
{
vector <__uint8> &v = info->content;
__uint8 *s = (__uint8*)ptr;
v.insert (v.end(), s, s + (size * nmemb));
}
}
int amount = (int)(size * nmemb);
bandWidth::updateAmount(bandWidth::AUTH_AND_METRICS, amount);
return amount;
}
authService::authService() : restart_time(0), in_use(false)
{
m_curl = webClient::setupCurlDefaults (NULL, LOGNAME, g_authURL, 4L);
//DEBUG_LOG("[AUTH] Starting auth instance");
}
authService::~authService()
{
restart_time = 0;
in_use = false;
if (m_curl)
{
curl_easy_cleanup(m_curl);
m_curl = NULL;
}
//DEBUG_LOG("[AUTH] Stopping auth instance");
}
THREAD_FUNC authService::process(void* arg)
{
try
{
authService* m_auth = reinterpret_cast<authService*>(arg);
if (m_auth)
{
if (!iskilled())
{
g_qMutex.lock();
while (!m_auth->clients.empty())
{
auth_info *info = m_auth->clients.front();
m_auth->clients.pop_front();
g_qMutex.unlock();
if (info)
{
if (info->url.empty() == false)
{
g_qMutex.lock();
m_auth->main_post = info->post;
m_auth->m_curl = webClient::setupCurlDefaults (m_auth->m_curl, LOGNAME, info->url, 4L);
DLOG ("updated main post to " + m_auth->main_post + " and URL " + info->url, LOGNAME, info->sid);
g_qMutex.unlock();
}
if (m_auth->restart_time && (::time(NULL) >= m_auth->restart_time))
{
m_auth->restart_time = 0;
DEBUG_LOG("Restarting disabled auth", LOGNAME, info->sid);
}
protocol_shoutcastClient *client = info->client;
if (client) // if set to be kicked then no point in processing
{
if (client->m_kickNextRound == false)
{
if (m_auth->restart_time)
{
// auth is disabled for now, but assume client is ok
info->authenticated = true;
}
else
{
if (info->post.empty() == false)
{
utf8 post = info->post + "&" + m_auth->main_post;
#if defined(_DEBUG) || defined(DEBUG)
DEBUG_LOG("POST body: " + utf8(post.c_str()), LOGNAME, info->sid);
#endif
char errormsg[CURL_ERROR_SIZE] = {0};
if (m_auth->m_curl)
{
curl_easy_setopt(m_auth->m_curl, CURLOPT_HEADERFUNCTION, handle_returned_header);
curl_easy_setopt(m_auth->m_curl, CURLOPT_WRITEFUNCTION, handle_returned_data);
curl_easy_setopt(m_auth->m_curl, CURLOPT_ERRORBUFFER, errormsg);
curl_easy_setopt(m_auth->m_curl, CURLOPT_HEADERDATA, info);
curl_easy_setopt(m_auth->m_curl, CURLOPT_WRITEDATA, info);
curl_easy_setopt(m_auth->m_curl, CURLOPT_POSTFIELDSIZE, post.size());
curl_easy_setopt(m_auth->m_curl, CURLOPT_COPYPOSTFIELDS, post.c_str());
// use progress/xfer functions to trap for the server kill case
curl_easy_setopt(m_auth->m_curl, CURLOPT_NOPROGRESS, 0L);
curl_easy_setopt(m_auth->m_curl, CURLOPT_XFERINFOFUNCTION, xferinfo);
curl_easy_setopt(m_auth->m_curl, CURLOPT_XFERINFODATA, info->sid);
}
CURLcode ret = CURLE_FAILED_INIT;
if (!m_auth->m_curl || ((ret = curl_easy_perform(m_auth->m_curl)) != CURLE_OK))
{
ELOG("[AUTH sid=" + tos(info->sid) + "] Request failed on auth with " +
(errormsg[0] ? errormsg : curl_easy_strerror(ret)));
g_qMutex.lock();
if (m_auth->restart_time == 0)
{
m_auth->restart_time = ::time(NULL) + 60;
}
g_qMutex.unlock();
info->authenticated = true;
}
}
}
if (info->authenticated)
{
// we need to double-check that the client still
// exists as there could have been a delay with
// the processing of this and it's since dropped
// or been kicked - if so we don't want to crash
//stats::
if (info->group >= 0)
{
client->setGroup(info->group);
}
if (info->has_intro)
{
DEBUG_LOG("[AUTH sid=" + tos(info->sid) + "] Listener auth supplied intro of " + tos((long)info->content.size()));
client->setIntro(info->content, info->m_dataType);
}
}
else
{
// if we didn't get the required header responses
// but we did get a valid response from the server
// then we should just allow the client to connect
// as we don't know what's going on so assume "ok"
if (!info->valid_response)
{
info->authenticated = true;
}
else
{
DEBUG_LOG("[AUTH sid=" + tos(info->sid) + "] Auth failed, 403 returned");
client->return_403();
}
}
}
// if we're re-processing the client then we
// musn't re-schedule it else it'll go boom!
if (!info->delayed_auth)
{
threadedRunner::scheduleRunnable(client);
}
}
}
delete info;
info = NULL;
g_qMutex.lock();
}
m_auth->clients.clear();
m_auth->in_use = false;
g_qMutex.unlock();
}
}
}
catch (...)
{
authService* m_auth = reinterpret_cast<authService*>(arg);
if (m_auth)
{
g_qMutex.lock();
m_auth->clients.clear();
m_auth->in_use = false;
g_qMutex.unlock();
}
}
return 0;
}
void schedule(auth_info *info)
{
if (info)
{
g_qMutex.lock();
do
{
if (g_queue.size() > AMNT_ALLOWED_BEFORE_SKIPPING)
{
// what to do when under stress/timeout
DEBUG_LOG(LOGNAME "Heavy backlog of auth requests, skipping");
threadedRunner::scheduleRunnable(info->client);
delete info;
info = NULL;
break;
}
if (g_services)
{
int i = 0;
for (; i < MAX_AUTH_THREADS; ++i)
{
if (g_services[i].in_use == false)
{
// start auth thread processing
g_services[i].in_use = true;
g_services[i].clients.push_back(info);
if (!g_queue.empty())
{
g_services[i].clients.insert(g_services[i].clients.end(), g_queue.begin(), g_queue.end());
g_queue.clear();
}
// do what we can to make sure that if we fail
// to start the thread then we'll pass it on
DEBUG_LOG(LOGNAME "Starting auth thread #" + tos(i+1));
SimpleThread(authService::process, &g_services[i]);
break;
}
}
if (i >= MAX_AUTH_THREADS)
{
g_queue.push_back(info);
//DEBUG_LOG(LOGNAME "Unable to process auth requests, skipping");
//threadedRunner::scheduleRunnable(info->client);
//delete info;
//info = NULL;
break;
}
}
else
{
DEBUG_LOG(LOGNAME "Unable to process auth requests, skipping");
info->authenticated = true;
threadedRunner::scheduleRunnable(info->client);
delete info;
info = NULL;
break;
}
// make sure that if things go arwy that we should be able to terminate
if (iskilled())
{
break;
}
} while (0);
g_qMutex.unlock();
}
}
void updateServices (bool initial)
{
if (g_services == NULL)
return;
httpHeaderMap_t vars;
vars["server"] = "Shoutcast v" + gOptions.getVersionBuildStrings();
vars["port"] = tos(g_portForClients);
utf8 main_post = encodeVariables(vars);
for (int i = 0; i < MAX_AUTH_THREADS; ++i)
{
if (initial)
{
g_services[i].main_post = main_post;
}
else
{
auth_info *info = new auth::auth_info (g_authURL);
info->post = main_post;
g_qMutex.lock();
g_services[i].clients.push_back (info);
if (g_services[i].in_use == false)
{
g_services[i].in_use = true;
SimpleThread(authService::process, &g_services[i]);
}
g_qMutex.unlock();
}
}
}
void init()
{
g_services = new authService[MAX_AUTH_THREADS];
if (g_services)
{
updateServices (true);
}
else
{
WLOG(LOGNAME "Failed to start auth service threads");
}
}
void cleanup()
{
if (g_services)
{
delete[] g_services;
g_services = NULL;
}
}
}
Reference in a new issue View git blame Copy permalink