putnode.cpp

/* Synchronet node information writing routines */

/****************************************************************************
 * @format.tab-size 4		(Plain Text/Source Code File Header)			*
 * @format.use-tabs true	(see http://www.synchro.net/ptsc_hdr.html)		*
 *																			*
 * Copyright Rob Swindell - http://www.synchro.net/copyright.html			*
 *																			*
 * This program 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 2			*
 * of the License, or (at your option) any later version.					*
 * See the GNU General Public License for more details: gpl.txt or			*
 * http://www.fsf.org/copyleft/gpl.html										*
 *																			*
 * For Synchronet coding style and modification guidelines, see				*
 * http://www.synchro.net/source.html										*
 *																			*
 * Note: If this box doesn't appear square, then you need to fix your tabs.	*
 ****************************************************************************/

#include "sbbs.h"

/****************************************************************************/
/* Write the data from the structure 'node' into node.dab  					*/
/* getnodedat(num,&node,1); must have been called before calling this func  */
/*          NOTE: ------^   the indicates the node record has been locked   */
/****************************************************************************/
bool sbbs_t::putnodedat(uint number, node_t* node)
{
	char tmp[128];
	char path[MAX_PATH + 1];
	int  wr = 0;
	int  wrerr = 0;
	int  attempts;

	if (number < 1 || number > cfg.sys_nodes) {
		errormsg(WHERE, ERR_CHK, "node number", number);
		return false;
	}
	if (number == cfg.node_num) {
		if ((node->status == NODE_INUSE || node->status == NODE_QUIET)
		    && node->action < NODE_LAST_ACTION
		    && text[NodeActionMainMenu + node->action][0]) {
			node->misc |= NODE_EXT;
			putnodeext(number, expand_atcodes(text[NodeActionMainMenu + node->action], tmp, sizeof tmp));
		}
		else
			node->misc &= ~NODE_EXT;
	}

	snprintf(path, sizeof path, "%snode.dab", cfg.ctrl_dir);
	pthread_mutex_lock(&nodefile_mutex);
	if (nodefile == -1) {
		if ((nodefile = nopen(path, O_CREAT | O_RDWR | O_DENYNONE)) == -1) {
			pthread_mutex_unlock(&nodefile_mutex);
			errormsg(WHERE, ERR_OPEN, path, O_CREAT | O_RDWR | O_DENYNONE);
			return false;
		}
	}

	for (attempts = 0; attempts < 10; attempts++) {
		if (seeknodedat(nodefile, number)) {
			wr = write(nodefile, node, sizeof(node_t));
			if (wr == sizeof(node_t))
				break;
			wrerr = errno;    /* save write error */
		}
		FILE_RETRY_DELAY(attempts + 1);
	}
	unlocknodedat(number);

	if (mqtt->connected) {
		int result = mqtt_putnodedat(mqtt, number, node);
		if (result != MQTT_SUCCESS)
			lprintf(LOG_WARNING, "ERROR %d (%d) publishing node status", result, errno);
	}
	if (wr != sizeof(node_t)) {
		errno = wrerr;
		errormsg(WHERE, ERR_WRITE, "nodefile", number);
		return false;
	}

	return utime(path, NULL) == 0;   /* Update mod time for NFS/smbfs compatibility */
}

bool sbbs_t::unlocknodedat(uint number)
{
	if (number < 1 || number > cfg.sys_nodes) {
		pthread_mutex_unlock(&nodefile_mutex);
		errormsg(WHERE, ERR_CHK, "node number", number);
		return false;
	}
	int result = unlock(nodefile, (number - 1) * sizeof(node_t), sizeof(node_t));
	if (cfg.node_misc & NM_CLOSENODEDAB) {
		close(nodefile);
		nodefile = -1;
	}
	pthread_mutex_unlock(&nodefile_mutex);
	return result == 0;
}

bool sbbs_t::putnodeext(uint number, char *ext)
{
	char str[MAX_PATH + 1];
	int  count;
	int  wr;

	if (number < 1 || number > cfg.sys_nodes) {
		errormsg(WHERE, ERR_CHK, "node number", number);
		return false;
	}
	number--;   /* make zero based */

	if ((node_ext = opennodeext(&cfg)) == -1) {
		errormsg(WHERE, ERR_OPEN, "node.exb", O_CREAT | O_RDWR | O_DENYNONE);
		return false;
	}
	for (count = 0; count < LOOP_NODEDAB; count++) {
		lseek(node_ext, (long)number * 128L, SEEK_SET);
		if (lock(node_ext, (long)number * 128L, 128) == 0) {
			wr = write(node_ext, ext, 128);
			unlock(node_ext, (long)number * 128L, 128);
			if (wr == 128)
				break;
		}
		FILE_RETRY_DELAY(count + 1);
	}
	close(node_ext);
	node_ext = -1;

	if (count > (LOOP_NODEDAB / 2) && count != LOOP_NODEDAB) {
		snprintf(str, sizeof str, "NODE.EXB (node %d) COLLISION - Count: %d"
		         , number + 1, count);
		logline(LOG_NOTICE, "!!", str);
	}
	if (count == LOOP_NODEDAB) {
		errormsg(WHERE, ERR_WRITE, "NODE.EXB", number + 1);
		return false;
	}

	return true;
}

bool sbbs_t::putnode_downloading(off_t size)
{
	action = NODE_DLNG;

	/* calculate ETA */
	time_t t = now;
	if (size < cur_cps)
		++t;
	else if (cur_cps > 0)
		t += size / cur_cps;
	struct tm tm;
	if (localtime_r(&t, &tm) != NULL)
		thisnode.aux = (tm.tm_hour * 60) + tm.tm_min;
	if (!getnodedat(cfg.node_num, &thisnode, /* lock-it: */ true))
		return false;
	thisnode.action = action;
	return putnodedat(cfg.node_num, &thisnode);
}