Commit 0fba6bab authored by Ed "oddsock" Zaleski's avatar Ed "oddsock" Zaleski
Browse files

style changes

svn path=/trunk/icecast/; revision=4316
parent 2848150f
......@@ -17,162 +17,159 @@
#include <curl/easy.h>
#define CATMODULE "CURL"
#define CATMODULE "geturl"
static CurlConnection curlConnections[NUM_CONNECTIONS];
static int nunConnections = NUM_CONNECTIONS;
static curl_connection curl_connections[NUM_CONNECTIONS];
mutex_t _curl_mutex;
size_t
WriteMemoryCallback(void *ptr, size_t size, size_t nmemb, void *data)
curl_write_memory_callback(void *ptr, size_t size, size_t nmemb, void *data)
{
register int realsize = size * nmemb;
register int realsize = size * nmemb;
struct MemoryStruct *mem = (struct MemoryStruct *)data;
struct curl_memory_struct *mem = (struct curl_memory_struct *)data;
if ((realsize + mem->size) < YP_RESPONSE_SIZE-1) {
strncat(mem->memory, ptr, realsize);
}
if ((realsize + mem->size) < YP_RESPONSE_SIZE-1) {
strncat(mem->memory, ptr, realsize);
}
return realsize;
return realsize;
}
size_t
HeaderMemoryCallback(void *ptr, size_t size, size_t nmemb, void *data)
curl_header_memory_callback(void *ptr, size_t size, size_t nmemb, void *data)
{
char *p1 = 0;
char *p2 = 0;
int copylen = 0;
register int realsize = size * nmemb;
struct MemoryStruct2 *mem = (struct MemoryStruct2 *)data;
if (!strncmp(ptr, "SID: ", strlen("SID: "))) {
p1 = (char *)ptr + strlen("SID: ");
p2 = strchr((const char *)p1, '\r');
memset(mem->sid, '\000', sizeof(mem->sid));
if (p2) {
if (p2-p1 > sizeof(mem->sid)-1) {
copylen = sizeof(mem->sid)-1;
}
else {
copylen = p2-p1;
}
strncpy(mem->sid, p1, copylen);
}
else {
strncpy(mem->sid, p1, sizeof(mem->sid)-1);
strcpy(mem->sid, p1);
}
}
if (!strncmp(ptr, "YPMessage: ", strlen("YPMessage: "))) {
p1 = (char *)ptr + strlen("YPMessage: ");
p2 = strchr((const char *)p1, '\r');
memset(mem->message, '\000', sizeof(mem->message));
if (p2) {
if (p2-p1 > sizeof(mem->message)-1) {
copylen = sizeof(mem->message)-1;
}
else {
copylen = p2-p1;
}
strncpy(mem->message, p1, copylen);
}
else {
strncpy(mem->message, p1, sizeof(mem->message)-1);
strcpy(mem->message, p1);
}
}
if (!strncmp(ptr, "TouchFreq: ", strlen("TouchFreq: "))) {
p1 = (char *)ptr + strlen("TouchFreq: ");
mem->touchFreq = atoi(p1);
}
if (!strncmp(ptr, "YPResponse: ", strlen("YPResponse: "))) {
p1 = (char *)ptr + strlen("YPResponse: ");
mem->response = atoi(p1);
}
return realsize;
char *p1 = 0;
char *p2 = 0;
int copylen = 0;
register int realsize = size * nmemb;
struct curl_memory_struct2 *mem = (struct curl_memory_struct2 *)data;
if (!strncmp(ptr, "SID: ", strlen("SID: "))) {
p1 = (char *)ptr + strlen("SID: ");
p2 = strchr((const char *)p1, '\r');
memset(mem->sid, '\000', sizeof(mem->sid));
if (p2) {
if (p2-p1 > sizeof(mem->sid)-1) {
copylen = sizeof(mem->sid)-1;
}
else {
copylen = p2-p1;
}
strncpy(mem->sid, p1, copylen);
}
else {
strncpy(mem->sid, p1, sizeof(mem->sid)-1);
strcpy(mem->sid, p1);
}
}
if (!strncmp(ptr, "YPMessage: ", strlen("YPMessage: "))) {
p1 = (char *)ptr + strlen("YPMessage: ");
p2 = strchr((const char *)p1, '\r');
memset(mem->message, '\000', sizeof(mem->message));
if (p2) {
if (p2-p1 > sizeof(mem->message)-1) {
copylen = sizeof(mem->message)-1;
}
else {
copylen = p2-p1;
}
strncpy(mem->message, p1, copylen);
}
else {
strncpy(mem->message, p1, sizeof(mem->message)-1);
strcpy(mem->message, p1);
}
}
if (!strncmp(ptr, "TouchFreq: ", strlen("TouchFreq: "))) {
p1 = (char *)ptr + strlen("TouchFreq: ");
mem->touch_freq = atoi(p1);
}
if (!strncmp(ptr, "YPResponse: ", strlen("YPResponse: "))) {
p1 = (char *)ptr + strlen("YPResponse: ");
mem->response = atoi(p1);
}
return realsize;
}
int curl_initialize()
{
int i = 0;
thread_mutex_create(&_curl_mutex);
memset(&curlConnections, '\000', sizeof(curlConnections));
for (i=0;i<NUM_CONNECTIONS;i++) {
curlConnections[i].curl_handle = curl_easy_init();
curl_easy_setopt(curlConnections[i].curl_handle, CURLOPT_WRITEFUNCTION, WriteMemoryCallback);
curl_easy_setopt(curlConnections[i].curl_handle, CURLOPT_WRITEHEADER, (void *)&(curlConnections[i].headerresult));
curl_easy_setopt(curlConnections[i].curl_handle, CURLOPT_HEADERFUNCTION, HeaderMemoryCallback);
curl_easy_setopt(curlConnections[i].curl_handle, CURLOPT_FILE, (void *)&(curlConnections[i].result));
}
return(1);
int i = 0;
thread_mutex_create(&_curl_mutex);
memset(&curl_connections, '\000', sizeof(curl_connections));
for (i=0; i<NUM_CONNECTIONS; i++) {
curl_connections[i].curl_handle = curl_easy_init();
curl_easy_setopt(curl_connections[i].curl_handle,
CURLOPT_WRITEFUNCTION, curl_write_memory_callback);
curl_easy_setopt(curl_connections[i].curl_handle,
CURLOPT_WRITEHEADER, (void *)&(curl_connections[i].header_result));
curl_easy_setopt(curl_connections[i].curl_handle,
CURLOPT_HEADERFUNCTION, curl_header_memory_callback);
curl_easy_setopt(curl_connections[i].curl_handle,
CURLOPT_FILE, (void *)&(curl_connections[i].result));
}
return(1);
}
void curl_shutdown()
{
int i = 0;
for (i=0;i<NUM_CONNECTIONS;i++) {
curl_easy_cleanup(curlConnections[i].curl_handle);
memset(&(curlConnections[i]), '\000', sizeof(curlConnections[i]));
}
int i = 0;
for (i=0; i<NUM_CONNECTIONS; i++) {
curl_easy_cleanup(curl_connections[i].curl_handle);
memset(&(curl_connections[i]), '\000', sizeof(curl_connections[i]));
}
}
int getCurlConnection()
int curl_get_connection()
{
int found = 0;
int curlConnection = -1;
int i = 0;
while (!found) {
thread_mutex_lock(&_curl_mutex);
for (i=0;i<NUM_CONNECTIONS;i++) {
if (!curlConnections[i].inUse) {
found = 1;
curlConnections[i].inUse = 1;
curlConnection = i;
break;
}
}
thread_mutex_unlock(&_curl_mutex);
int found = 0;
int curl_connection = -1;
int i = 0;
while (!found) {
thread_mutex_lock(&_curl_mutex);
for (i=0; i<NUM_CONNECTIONS; i++) {
if (!curl_connections[i].in_use) {
found = 1;
curl_connections[i].in_use = 1;
curl_connection = i;
break;
}
}
thread_mutex_unlock(&_curl_mutex);
#ifdef WIN32
Sleep(200);
Sleep(200);
#else
usleep(200);
usleep(200);
#endif
}
return(curlConnection);
}
return(curl_connection);
}
int releaseCurlConnection(int which)
int curl_release_connection(int which)
{
thread_mutex_lock(&_curl_mutex);
curlConnections[which].inUse = 0;
memset(&(curlConnections[which].result), '\000', sizeof(curlConnections[which].result));
memset(&(curlConnections[which].headerresult), '\000', sizeof(curlConnections[which].headerresult));
thread_mutex_unlock(&_curl_mutex);
return 1;
thread_mutex_lock(&_curl_mutex);
curl_connections[which].in_use = 0;
memset(&(curl_connections[which].result), '\000',
sizeof(curl_connections[which].result));
memset(&(curl_connections[which].header_result), '\000',
sizeof(curl_connections[which].header_result));
thread_mutex_unlock(&_curl_mutex);
return 1;
}
void printHeaderResult(struct MemoryStruct2 *mem) {
DEBUG1("SID -> (%s)", mem->sid);
DEBUG1("Message -> (%s)", mem->message);
DEBUG1("Touch Freq -> (%d)", mem->touchFreq);
DEBUG1("Response -> (%d)", mem->response);
void curl_print_header_result(struct curl_memory_struct2 *mem) {
DEBUG1("SID -> (%s)", mem->sid);
DEBUG1("Message -> (%s)", mem->message);
DEBUG1("Touch Freq -> (%d)", mem->touch_freq);
DEBUG1("Response -> (%d)", mem->response);
}
CURL *getCurlHandle(int which)
CURL *curl_get_handle(int which)
{
return curlConnections[which].curl_handle;
return curl_connections[which].curl_handle;
}
struct MemoryStruct *getCurlResult(int which)
struct curl_memory_struct *curl_get_result(int which)
{
return &(curlConnections[which].result);
return &(curl_connections[which].result);
}
struct MemoryStruct2 *getCurlHeaderResult(int which)
struct curl_memory_struct2 *curl_get_header_result(int which)
{
return &(curlConnections[which].headerresult);
return &(curl_connections[which].header_result);
}
......@@ -13,33 +13,33 @@
#define YP_RESPONSE_SIZE 2046
#define YP_SID_SIZE 255
struct MemoryStruct {
char memory[YP_RESPONSE_SIZE];
size_t size;
struct curl_memory_struct {
char memory[YP_RESPONSE_SIZE];
size_t size;
};
struct MemoryStruct2 {
char sid[YP_SID_SIZE];
char message[YP_RESPONSE_SIZE];
int touchFreq;
int response;
size_t size;
struct curl_memory_struct2 {
char sid[YP_SID_SIZE];
char message[YP_RESPONSE_SIZE];
int touch_freq;
int response;
size_t size;
};
typedef struct tag_CurlConnection {
struct MemoryStruct result;
struct MemoryStruct2 headerresult;
CURL *curl_handle;
int inUse;
} CurlConnection;
typedef struct tag_curl_connection {
struct curl_memory_struct result;
struct curl_memory_struct2 header_result;
CURL *curl_handle;
int in_use;
} curl_connection;
int curl_initialize();
void curl_shutdown();
CURL *getCurlHandle(int which);
struct MemoryStruct *getCurlResult(int which);
struct MemoryStruct2 *getCurlHeaderResult(int which);
void printHeaderResult(struct MemoryStruct2 *mem);
int getCurlConnection();
int releaseCurlConnection(int which);
CURL *curl_get_handle(int which);
struct curl_memory_struct *curl_get_result(int which);
struct curl_memory_struct2 *curl_get_header_result(int which);
void curl_print_header_result(struct curl_memory_struct2 *mem);
int curl_get_connection();
int curl_release_connection(int which);
#endif
......@@ -57,7 +57,7 @@ source_t *source_create(client_t *client, connection_t *con, http_parser_t *pars
src->listeners = 0;
for (i=0;i<config_get_config()->num_yp_directories;i++) {
if (config_get_config()->yp_url[i]) {
src->ypdata[src->num_yp_directories] = create_ypdata();
src->ypdata[src->num_yp_directories] = yp_create_ypdata();
src->ypdata[src->num_yp_directories]->yp_url = config_get_config()->yp_url[i];
src->ypdata[src->num_yp_directories]->yp_url_timeout = config_get_config()->yp_url_timeout[i];
src->ypdata[src->num_yp_directories]->yp_touch_freq = 0;
......@@ -117,9 +117,9 @@ int source_free_source(void *key)
avl_tree_free(source->pending_tree, _free_client);
avl_tree_free(source->client_tree, _free_client);
source->format->free_plugin(source->format);
for (i=0;i<source->num_yp_directories;i++) {
destroy_ypdata(source->ypdata[i]);
}
for (i=0; i<source->num_yp_directories; i++) {
yp_destroy_ypdata(source->ypdata[i]);
}
free(source);
return 1;
......
......@@ -12,364 +12,340 @@
#include "source.h"
#include "config.h"
#define CATMODULE "YP"
#define CATMODULE "yp"
int yp_submit_url(int curlCon, char *yp_url, char *pURL, char *type)
int yp_submit_url(int curl_con, char *yp_url, char *url, char *type)
{
int ret = 0;
curl_easy_setopt(getCurlHandle(curlCon), CURLOPT_URL, yp_url);
curl_easy_setopt(getCurlHandle(curlCon), CURLOPT_POSTFIELDS, pURL);
curl_easy_setopt(getCurlHandle(curlCon), CURLOPT_TIMEOUT, config_get_config()->yp_url_timeout);
/* get it! */
memset(getCurlResult(curlCon), '\000', sizeof(struct MemoryStruct));
memset(getCurlHeaderResult(curlCon), '\000', sizeof(struct MemoryStruct2));
curl_easy_perform(getCurlHandle(curlCon));
printHeaderResult(getCurlHeaderResult(curlCon));
if (getCurlHeaderResult(curlCon)->response == ACK) {
INFO2("Successfull ACK from %s (%s)", type, yp_url);
ret = 1;
}
else {
if (strlen(getCurlHeaderResult(curlCon)->message) > 0) {
ERROR3("Got a NAK from %s(%s) (%s)", type,getCurlHeaderResult(curlCon)->message, yp_url);
}
else {
ERROR2("Got a NAK from %s(Unknown) (%s)", type, yp_url);
}
ret = 0;
}
return ret;
int ret = 0;
curl_easy_setopt(curl_get_handle(curl_con), CURLOPT_URL, yp_url);
curl_easy_setopt(curl_get_handle(curl_con), CURLOPT_POSTFIELDS, url);
curl_easy_setopt(curl_get_handle(curl_con), CURLOPT_TIMEOUT, config_get_config()->yp_url_timeout);
/* get it! */
memset(curl_get_result(curl_con), '\000', sizeof(struct curl_memory_struct));
memset(curl_get_header_result(curl_con), '\000', sizeof(struct curl_memory_struct2));
curl_easy_perform(curl_get_handle(curl_con));
curl_print_header_result(curl_get_header_result(curl_con));
if (curl_get_header_result(curl_con)->response == ACK) {
INFO2("Successfull ACK from %s (%s)", type, yp_url);
ret = 1;
}
else {
if (strlen(curl_get_header_result(curl_con)->message) > 0) {
ERROR3("Got a NAK from %s(%s) (%s)", type,curl_get_header_result(curl_con)->message, yp_url);
}
else {
ERROR2("Got a NAK from %s(Unknown) (%s)", type, yp_url);
}
ret = 0;
}
return ret;
}
void *yp_touch_thread(void *arg)
{
yp_touch((source_t *)arg);
thread_exit(0);
return NULL;
yp_touch((source_t *)arg);
thread_exit(0);
return NULL;
}
int yp_remove(void *psource)
{
char *pURL = NULL;
int pURLsize = 0;
int ret = 0;
int curlCon = 0;
char *p1 = NULL;
int i = 0;
int regenSID = 0;
long currentTime = 0;
source_t *source = (source_t *)psource;
currentTime = time(&currentTime);
for (i=0;i<source->num_yp_directories;i++) {
source->ypdata[i]->yp_last_touch = currentTime;
if (source->ypdata[i]->sid == 0) {
return 0;
}
else {
if (strlen(source->ypdata[i]->sid) == 0) {
return 0;
}
}
if (source->ypdata) {
pURLsize = strlen("action=remove&sid=") + 1;
pURLsize += strlen(source->ypdata[i]->sid);
pURLsize += 1024;
pURL = (char *)malloc(pURLsize);
memset(pURL, '\000', pURLsize);
sprintf(pURL, "action=remove&sid=%s",
source->ypdata[i]->sid);
curlCon = getCurlConnection();
if (curlCon < 0) {
ERROR0("Unable to get auth connection");
}
else {
/* specify URL to get */
ret = yp_submit_url(curlCon, source->ypdata[i]->yp_url, pURL, "yp_remove");
}
if (pURL) {
free(pURL);
}
releaseCurlConnection(curlCon);
}
}
return 1;
char *url = NULL;
int url_size = 0;
int ret = 0;
int curl_con = 0;
char *p1 = NULL;
int i = 0;
int regen_sid = 0;
long current_time = 0;
source_t *source = (source_t *)psource;
current_time = time(&current_time);
for (i=0; i<source->num_yp_directories; i++) {
source->ypdata[i]->yp_last_touch = current_time;
if (source->ypdata[i]->sid == 0) {
return 0;
}
else {
if (strlen(source->ypdata[i]->sid) == 0) {
return 0;
}
}
if (source->ypdata) {
url_size = strlen("action=remove&sid=") + 1;
url_size += strlen(source->ypdata[i]->sid);
url_size += 1024;
url = (char *)malloc(url_size);
memset(url, '\000', url_size);
sprintf(url, "action=remove&sid=%s",
source->ypdata[i]->sid);
curl_con = curl_get_connection();
if (curl_con < 0) {
ERROR0("Unable to get auth connection");
}
else {
/* specify URL to get */
ret = yp_submit_url(curl_con, source->ypdata[i]->yp_url, url, "yp_remove");
}
if (url) {
free(url);
}
curl_release_connection(curl_con);
}
}
return 1;
}
int yp_touch(void *psource)
{
char *pURL = NULL;
int pURLsize = 0;
int ret = 0;
int curlCon = 0;
char *p1 = NULL;
int i = 0;
int regenSID = 0;
long currentTime = 0;
source_t *source = (source_t *)psource;
currentTime = time(&currentTime);
for (i=0;i<source->num_yp_directories;i++) {
source->ypdata[i]->yp_last_touch = currentTime;
if (source->ypdata[i]->sid == 0) {
regenSID = 1;
}
else {
if (strlen(source->ypdata[i]->sid) == 0) {
regenSID = 1;
}
}
if (regenSID) {
if (!yp_add(source, i)) {
return 0;
}
}
if (source->ypdata) {
pURLsize = strlen("action=touch&sid=&st=&listeners=") + 1;
if (source->ypdata[i]->current_song) {
pURLsize += strlen(source->ypdata[i]->current_song);
}
else {
source->ypdata[i]->current_song = (char *)malloc(1);
memset(source->ypdata[i]->current_song, '\000', 1);
}
if (source->ypdata[i]->sid) {
pURLsize += strlen(source->ypdata[i]->sid);
}
else {
source->ypdata[i]->sid = (char *)malloc(1);
memset(source->ypdata[i]->sid, '\000', 1);
}
pURLsize += 1024;
pURL = (char *)malloc(pURLsize);
memset(pURL, '\000', pURLsize);
sprintf(pURL, "action=touch&sid=%s&st=%s&listeners=%d",
source->ypdata[i]->sid,
source->ypdata[i]->current_song,
source->listeners);
curlCon = getCurlConnection();
if (curlCon < 0) {
ERROR0("Unable to get auth connection");
}
else {
/* specify URL to get */
ret = yp_submit_url(curlCon, source->ypdata[i]->yp_url, pURL