style changes

svn path=/trunk/icecast/; revision=4316

src/geturl.c

@@ -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);
 }

src/geturl.h

@@ -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
 

src/source.c

@@ -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;

src/yp.h

@@ -25,8 +25,8 @@ void *yp_touch_thread(void *arg);
 int yp_add(void *psource, int which);
 int yp_touch(void *psource);
 int yp_remove(void *psource);
-ypdata_t *create_ypdata();
-void destroy_ypdata(ypdata_t *ypdata);
+ypdata_t *yp_create_ypdata();
+void yp_destroy_ypdata(ypdata_t *ypdata);
 
 #endif