uIRC/src/memory/struct.c

/*
 *  This file is part of uIRC. (https://git.redxen.eu/caskd/uIRC)
 *  Copyright (c) 2019, 2020 Alex-David Denes
 *
 *  uIRC is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  any later version.
 *
 *  uIRC is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with uIRC.  If not, see <https://www.gnu.org/licenses/>.
 */

#include "memory.h"
#include "types.h" // IRC_*

#include <assert.h>             // assert()
#include <corelibs/stringext.h> // malloc_string()
#include <stdlib.h>             // free()
#include <string.h>             // strlen()

void*
uirc_struct_malloc(const void* src, IRC_Struct_Type type)
{
	assert(src != NULL);

	void*  ret        = NULL;
	size_t structsize = 0;

	switch (type) {
#ifdef UIRC_FEATURE_IRCV3
		case IRC_STRUCT_TAG: structsize = sizeof(IRC_Tag); break;
		case IRC_STRUCT_CAPABILITY: structsize = sizeof(IRC_Capability); break;
#endif /* UIRC_FEATURE_IRCV3 */
		case IRC_STRUCT_USER: structsize = sizeof(IRC_User); break;
		case IRC_STRUCT_MESSAGE: structsize = sizeof(IRC_Message); break;
		case IRC_STRUCT_BUFFER: structsize = sizeof(IRC_Buffer); break;
		case IRC_STRUCT_NETWORK: structsize = sizeof(IRC_Network); break;
	}

	if ((ret = malloc(structsize)) == NULL) return NULL;
	memset(ret, 0, structsize);

	switch (type) {
#ifdef UIRC_FEATURE_IRCV3
		case IRC_STRUCT_TAG: {
			IRC_Tag*       c_ret = ret;
			const IRC_Tag* c_src = src;

			c_ret->clientbound = c_src->clientbound;
			if (((c_ret->key = malloc_string(c_src->key, strlen(c_src->key))) == NULL)
			    || (c_src->value != NULL && (c_ret->value = malloc_string(c_src->value, strlen(c_src->value))) == NULL))
				break;

			return ret;
		}
		case IRC_STRUCT_CAPABILITY: {
			IRC_Capability*       c_ret = ret;
			const IRC_Capability* c_src = src;

			c_ret->active = c_src->active;
			if ((c_ret->name = malloc_string(c_src->name, strlen(c_src->name))) == NULL) break;

			return ret;
		}
#endif /* UIRC_FEATURE_IRCV3 */
		case IRC_STRUCT_USER: {
			IRC_User*       c_ret = ret;
			const IRC_User* c_src = src;

			c_ret->modes      = c_src->modes;
			c_ret->is_service = c_src->is_service;
			if ((c_src->nick != NULL && (c_ret->nick = malloc_string(c_src->nick, strlen(c_src->nick))) == NULL)
			    || (c_src->user != NULL && (c_ret->user = malloc_string(c_src->user, strlen(c_src->user))) == NULL)
			    || (c_src->real != NULL && (c_ret->real = malloc_string(c_src->real, strlen(c_src->real))) == NULL)
			    || (c_src->host != NULL && (c_ret->host = malloc_string(c_src->host, strlen(c_src->host))) == NULL))
				break;

			return ret;
		}
		case IRC_STRUCT_MESSAGE: {
			IRC_Message*       c_ret = ret;
			const IRC_Message* c_src = src;

			c_ret->trailing = c_src->trailing;
			if ((c_ret->command = malloc_string(c_src->command, strlen(c_src->command))) == NULL) break;

			for (unsigned short i = 0; i < IRC_MAXARGS && c_src->args[i] != NULL; i++)
				if ((c_ret->args[i] = malloc_string(c_src->args[i], strlen(c_src->args[i]))) == NULL) break;

			return ret;
		}
		case IRC_STRUCT_BUFFER: {
			IRC_Buffer*       c_ret = ret;
			const IRC_Buffer* c_src = src;

			c_ret->modes      = c_src->modes;
			c_ret->subscribed = c_src->subscribed;
			if ((c_ret->name = malloc_string(c_src->name, strlen(c_src->name))) == NULL
			    || (c_src->topic != NULL && (c_ret->topic = malloc_string(c_src->topic, strlen(c_src->topic))) == NULL)
			    || (c_src->key != NULL && (c_ret->key = malloc_string(c_src->key, strlen(c_src->key))) == NULL))
				break;
			return ret;
		}
		case IRC_STRUCT_NETWORK: {
			IRC_Network*       c_ret = ret;
			const IRC_Network* c_src = src;

			if ((c_ret->addr = malloc_string(c_src->addr, strlen(c_src->addr))) == NULL
			    || (c_src->svc != NULL && (c_ret->svc = malloc_string(c_src->svc, strlen(c_src->svc))) == NULL)
			    || (c_src->pass != NULL && (c_ret->pass = malloc_string(c_src->pass, strlen(c_src->pass))) == NULL))
				break;

			return ret;
		}
	}
	uirc_struct_free(ret, type);
	free(ret);
	return NULL;
}

void
uirc_struct_free(void* obj, IRC_Struct_Type type)
{
	assert(obj != NULL);
	switch (type) {
#ifdef UIRC_FEATURE_IRCV3
		case IRC_STRUCT_TAG: {
			IRC_Tag* tmpob = obj;
			free(tmpob->key);
			free(tmpob->value);
			break;
		}
		case IRC_STRUCT_CAPABILITY: {
			IRC_Capability* tmpob = obj;
			free(tmpob->name);
			break;
		}
#endif /* UIRC_FEATURE_IRCV3 */
		case IRC_STRUCT_USER: {
			IRC_User* tmpob = obj;
			free(tmpob->nick);
			free(tmpob->user);
			free(tmpob->real);
			free(tmpob->host);
			break;
		}
		case IRC_STRUCT_MESSAGE: {
			IRC_Message* tmpob = obj;
			free(tmpob->command);
			if (tmpob->source != NULL) {
				uirc_struct_free(tmpob->source, IRC_STRUCT_USER);
				free(tmpob->source);
			}
#ifdef UIRC_FEATURE_IRCV3
			if (tmpob->tag_list != NULL) uirc_list_free(tmpob->tag_list, IRC_STRUCT_TAG);
#endif /* UIRC_FEATURE_IRCV3 */
			for (unsigned short i = 0; i < IRC_MAXARGS && tmpob->args[i] != NULL; i++) free(tmpob->args[i]);
			break;
		}
		case IRC_STRUCT_BUFFER: {
			IRC_Buffer* tmpob = obj;
			free(tmpob->name);
			free(tmpob->key);
			free(tmpob->topic);
			if (tmpob->message_list != NULL) uirc_list_free(tmpob->message_list, IRC_STRUCT_MESSAGE);
			if (tmpob->user_list != NULL) uirc_list_free(tmpob->user_list, IRC_STRUCT_USER);
			break;
		}
		case IRC_STRUCT_NETWORK: {
			IRC_Network* tmpob = obj;
			free(tmpob->addr);
			free(tmpob->svc);
			free(tmpob->pass);
			if (tmpob->user != NULL) {
				uirc_struct_free(tmpob->user, IRC_STRUCT_USER);
				free(tmpob->user);
			}
#ifdef UIRC_FEATURE_IRCV3
			if (tmpob->cap_list != NULL) uirc_list_free(tmpob->cap_list, IRC_STRUCT_CAPABILITY);
#endif /* UIRC_FEATURE_IRCV3 */
			if (tmpob->buf_list != NULL) uirc_list_free(tmpob->buf_list, IRC_STRUCT_BUFFER);
			break;
		}
	}
}