uIRC/src/memory/struct.c

/*
 *  This file is part of uIRC. (https://git.redxen.eu/caskd/uIRC)
 *  Copyright (c) 2019-2021 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 <stdarg.h>
#include <stdlib.h> // free()
#include <string.h> // strlen()

void*
uirc_struct_copy(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;
		}
	}
}

#ifdef UIRC_FEATURE_IRCV3
IRC_Tag*
uirc_struct_assm_tag(bool clientbound, const char* key, const char* value)
{
	assert(key != NULL);
	IRC_Tag* t = malloc(sizeof(*t));
	memset(t, 0, sizeof(*t));

	t->clientbound = clientbound;
	if ((t->key = malloc_string(key, strlen(key))) == NULL || (value != NULL && (t->value = malloc_string(value, strlen(value))) == NULL)) {
		uirc_struct_free(t, IRC_STRUCT_TAG);
		free(t);
		return NULL;
	}
	return t;
}

IRC_Capability*
uirc_struct_assm_capability(bool active, const char* name)
{
	assert(name != NULL);
	IRC_Capability* c = malloc(sizeof(*c));
	memset(c, 0, sizeof(*c));

	c->active = active;
	if ((c->name = malloc_string(name, strlen(name))) == NULL) {
		uirc_struct_free(c, IRC_STRUCT_CAPABILITY);
		free(c);
		return NULL;
	}
	return c;
}
#endif /* UIRC_FEATURE_IRCV3 */

IRC_User*
uirc_struct_assm_user(bool service, IRC_Modes modes, const char* nick, const char* user, const char* real, const char* host)
{
	IRC_User* u = malloc(sizeof(*u));
	memset(u, 0, sizeof(*u));

	u->is_service = service;
	u->modes      = modes;
	if ((nick != NULL && (u->nick = malloc_string(nick, strlen(nick))) == NULL)
	    || (user != NULL && (u->user = malloc_string(user, strlen(user))) == NULL)
	    || (real != NULL && (u->real = malloc_string(real, strlen(real))) == NULL)
	    || (host != NULL && (u->host = malloc_string(host, strlen(host))) == NULL)) {
		uirc_struct_free(u, IRC_STRUCT_USER);
		free(u);
		return NULL;
	}
	return u;
}

IRC_Message*
uirc_struct_assm_message(const char* cmd, bool trailing, unsigned int argc, ...)
{
	assert(cmd != NULL);
	IRC_Message* m = malloc(sizeof(*m));
	memset(m, 0, sizeof(*m));

	m->trailing = trailing;
	if (cmd != NULL && (m->command = malloc_string(cmd, strlen(cmd))) == NULL) {
		uirc_struct_free(m, IRC_STRUCT_MESSAGE);
		free(m);
		return NULL;
	}
	va_list ap;
	va_start(ap, argc);
	for (unsigned short i = 0; i < IRC_MAXARGS && i < argc; i++) {
		const char* carg = va_arg(ap, const char*);
		if ((m->args[i] = malloc_string(carg, strlen(carg))) == NULL) {
			uirc_struct_free(m, IRC_STRUCT_MESSAGE);
			free(m);
			return NULL;
		}
	}
	va_end(ap);
	return m;
}

IRC_Buffer*
uirc_struct_assm_buffer(IRC_Buffer_Type type, IRC_Modes modes, bool subscribed, const char* name, const char* key, const char* topic)
{
	assert(name != NULL);
	IRC_Buffer* b = malloc(sizeof(*b));
	memset(b, 0, sizeof(*b));

	b->subscribed = subscribed;
	b->modes      = modes;
	b->type       = type;
	if ((b->name = malloc_string(name, strlen(name))) == NULL || (key != NULL && (b->name = malloc_string(key, strlen(key))) == NULL)
	    || (topic != NULL && (b->topic = malloc_string(topic, strlen(topic))) == NULL)) {
		uirc_struct_free(b, IRC_STRUCT_BUFFER);
		free(b);
		return NULL;
	}
	return b;
}

IRC_Network*
uirc_struct_assm_network(const char* addr, const char* svc, const char* pass)
{
	IRC_Network* n = malloc(sizeof(*n));
	memset(n, 0, sizeof(*n));

	if ((addr != NULL && (n->addr = malloc_string(addr, strlen(addr))) == NULL)
	    || (svc != NULL && (n->svc = malloc_string(svc, strlen(svc))) == NULL)
	    || (pass != NULL && (n->pass = malloc_string(pass, strlen(pass))) == NULL)) {
		uirc_struct_free(n, IRC_STRUCT_NETWORK);
		free(n);
		return NULL;
	}
	return n;
}