메모리 릭. 고수님들 도와주세요. ㅠㅠ

#include <bson.h>
#include <json.h>
 
#include <stdio.h>
#include <unistd.h>
#include <glib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <mongo.h>
#include "logfile.h"
 
#define PORT 8899
#define BUFSIZE 65545
 
static bson *json_to_bson (struct json_object *json);
char *strSplit(char recv[BUFSIZE], char *splitStr);
 
static void
json_key_to_bson_key (bson *b, void *val,
		      const gchar *key)
{
  switch (json_object_get_type (val))
    {
    case json_type_boolean:
      bson_append_boolean (b, key, json_object_get_boolean (val));
      break;
    case json_type_double:
      bson_append_double (b, key, json_object_get_double (val));
      break;
    case json_type_int:
      bson_append_int32 (b, key , json_object_get_int (val));
      break;
    case json_type_object:
      {
	bson *sub;
 
	sub = json_to_bson (val);
	bson_append_document (b, key, sub);
	bson_free (sub);
	break;
      }
    case json_type_array:
      {
	gint pos;
	bson *sub;
 
	sub = bson_new ();
 
	for (pos = 0; pos < json_object_array_length (val); pos++)
	  {
	    gchar *nk = g_strdup_printf ("%d", pos);
 
	    json_key_to_bson_key (sub, json_object_array_get_idx (val, pos),
				  nk);
	    g_free (nk);
	  }
 
	bson_finish (sub);
 
	bson_append_array (b, key, sub);
	bson_free (sub);
	break;
      }
    case json_type_string:
      bson_append_string (b, key, json_object_get_string (val), -1);
      break;
    default:
      break;
    }
}
 
static bson *
json_to_bson (struct json_object *json)
{
	bson *b;
 
   b = bson_new ();
   {
	   json_object_object_foreach (json, key, val)
        {
		   	json_key_to_bson_key (b, val, key);
		}
   }
  bson_finish (b);
 
  return b;
}
 
struct json_object *
jsonStr_to_jsonStruct(char *jsonStr)
{
	static struct json_object *json;
 
   const GString *json_str = g_string_new(jsonStr);
   //GError *error = NULL;
   struct json_tokener *tokener;
 
   tokener = json_tokener_new ();
 
   //while (g_io_channel_read_line_string (input, json_str, NULL, &error) == G_IO_STATUS_NORMAL)
   {
      //struct json_object *json;
      bson *bson;
 
      json_tokener_reset (tokener);
 
      json = json_tokener_parse_ex (tokener, json_str->str, json_str->len);
      if (!json)
	   {
    	  //fprintf (stderr, "Error parsing json: %s:%d:%d\n", json_str->str, strlen(json_str->str), json_str->len);
    	  //Trace((1,"Error parsing json: %s:%d:%d\n", json_str->str, strlen(json_str->str), json_str->len));
    	  return NULL;
	   }
 
      if (json_object_get_type (json) != json_type_object)
	   {
    	  fprintf (stderr,"Error: json's top-level object is not object: %s\n",json_str->str);
    	  json_object_put (json);
    	  return NULL;
	   }
 
      /*
      bson = json_to_bson (json);
 
      json_object_put (json);
 
      write (1, bson_data (bson), bson_size (bson));
 
      bson_free (bson);
      */
 
 
 
 
    }
       json_tokener_free(tokener);
       g_string_free(json_str, json_str->len);
       return json;
}
 
int main(void) {
	int sockfd;
	struct sockaddr_in servAddr;
	struct sockaddr_in clntAddr;
	char recvBuffer[BUFSIZE];
	int clntLen;
	int recvLen;
 
	char strJSON[BUFSIZE];
 
	if((sockfd=socket(AF_INET, SOCK_DGRAM, 0))==-1){
		perror("sock failed");
		exit(1);
	}
 
	memset(&servAddr, 0, sizeof(servAddr));
 
	servAddr.sin_family = AF_INET;
 
	servAddr.sin_addr.s_addr = htonl(INADDR_ANY);
 
	servAddr.sin_port = htons(PORT);
 
	if(bind(sockfd, (struct sockaddr*)&servAddr, sizeof(servAddr)) == -1)
	{
		perror("bind failed");
		exit(1);
	}
 
 
	 mongo_sync_connection *conn;
 
	 conn = mongo_sync_connect ("192.168.10.103", 27017, FALSE);
	    if (!conn)
	      {
	        perror ("mongo_sync_connect()");
	        exit (1);
	      }
 
	    char colName[50];
 
	    char *tmp;
 
	    struct json_object *json;
 
	    char *result;
 
	while(1)
	{
		clntLen = sizeof(clntAddr);
 
		    if((recvLen=recvfrom(sockfd, recvBuffer, BUFSIZE-1, 0, (struct sockaddr*)&clntAddr, &clntLen))== -1)
			{
				perror("recvfrom failed");
				exit(1);
			}
 
			 //printf("%d\n", /*recvBuffer,*/ recvLen);
 
			 //char *strJSON;
 
			 memset(strJSON, 0, BUFSIZE);
 
			 tmp = strSplit(recvBuffer, "}{");
 
			 if(tmp == NULL || tmp == 0)
			 				 continue;
 
			 strcpy(strJSON, tmp);
 
			 //free(tmp);
 
			 while(1)
			 {
				 if(strstr(strJSON, "{\"type\":\"AGENT\"")!=NULL)
				 {
					 strcpy(colName, "db.AGENT\0");
				 }
				 else if(strstr(strJSON, "{\"type\":\"ASSSET\"")!=NULL)
				 {
					 strcpy(colName, "db.ASSSET\0");
				 }
				 else if(strstr(strJSON, "{\"type\":\"ASSSETITEM\"")!=NULL)
				 {
					 strcpy(colName, "db.ASSSETITEM\0");
				 }
				 else if(strstr(strJSON, "{\"type\":\"EVENT\"")!=NULL)
 				 {
					 strcpy(colName, "db.EVENT\0");
 				 }
				 else if(strstr(strJSON, "{\"type\":\"PERF\"")!=NULL)
 				 {
					 strcpy(colName, "db.PERF\0");
 				 }
				 else if(strstr(strJSON, "{\"type\":\"PERFITEM\"")!=NULL)
 				 {
					 strcpy(colName, "db.PERFITEM\0");
 				 }
				 else if(strstr(strJSON, "{\"type\":\"REAL\"")!=NULL)
 				 {
					 strcpy(colName, "db.REAL\0");
 				 }
				 else if(strstr(strJSON, "{\"type\":\"REALITEM\"")!=NULL)
 				 {
					 strcpy(colName, "db.REALITEM\0");
 				 }
				 else
				 {
					 continue;
				 }
 
				 json = jsonStr_to_jsonStruct(strJSON);
 
				 if(json == NULL)
				 {
					 //free(json);
					 break;
				 }
 
				 bson *b = json_to_bson(json);
 
				 if (!mongo_sync_cmd_insert (conn, colName, b, NULL))
					         {
					           perror ("mongo_sync_cmd_insert()");
					           exit (1);
					         }
				 else
 
				 {
					 //printf("OK:%s:%d\n",strJSON, strlen(strJSON));
				 }
 
				 //free(colName);
 
				 bson_free (b);
 
				 if(b == NULL)
					 break;
 
				 result = strSplit(NULL, "}{");
 
				 if(result == NULL)
					 break;
 
				 strcpy(strJSON, result);
 
				 //free(result);
 
				 if(strJSON == NULL || strlen(strJSON) == 0)
				 {
					 break;
				 }
			 }
	}
 
	    printf("END\n");
	    mongo_sync_disconnect (conn);
}
 
char *strSplit(char recv[BUFSIZE], char *splitStr)
{
	static char strBuffer[BUFSIZE];
	static int IsEnd = 0;
	static char result[BUFSIZE];
	static char  *ptr;
	static char tmpResult [BUFSIZE];
	static int nLenStrBuffer;
	static int nLenPtr;
	static int nEnd;
 
	if(IsEnd)
	{
		IsEnd = 0;
		return NULL;
	}
 
	if(recv!=NULL)
	{
		memset(strBuffer, 0, BUFSIZE);
		strcpy(strBuffer, recv);
 
		//free(recv);
	}
 
	ptr = strstr(strBuffer, splitStr);
 
 
 
		if(ptr == NULL)
		{
			IsEnd = 1;
 
			free(ptr);
 
			return strBuffer;
		}
		else
		{
			memset(tmpResult, 0, BUFSIZE);
			strcpy(tmpResult, ptr);
 
			nLenStrBuffer = strlen(strBuffer);
			nLenPtr = strlen(ptr)-1;
 
			//free(ptr);
 
			nEnd = nLenStrBuffer - nLenPtr;
 
			memset(result, 0, BUFSIZE);
 
			strncpy(result, strBuffer,  nEnd);
 
			//printf("strSplit:%d\n", /*result,*/ nEnd);
 
			memset(strBuffer, 0, BUFSIZE);
 
			strcpy(strBuffer, tmpResult+1);
 
			//free(tmpResult);
 
		   return result;
		}
 
 
}