glest-source/source/shared_lib/sources/feathery_ftp/ftpLib.c

/**
 * Feathery FTP-Server <https://sourceforge.net/projects/feathery>
 * Copyright (C) 2005-2010 Andreas Martin (andreas.martin@linuxmail.org)
 *
 * ftpLib.c - Global helper functions
 *
 *
 * 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 3 of the License, or
 * (at your option) any later version.
 *
 * This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <string.h>
#include <stdarg.h>

#include "ftpTypes.h"
#include "ftpConfig.h"
#include "ftp.h"
#include "ftpIfc.h"

 /**
  *  @brief Removes the trailing slash of a directory path
  *
  *  @param path   directory path
  *
  *  @return len of path
  */
int ftpRemoveTrailingSlash(char* path) {
	size_t len = strlen(path);

	if (len > 1) {
		len--;
		if (path[len] == '/')
			path[len] = '\0';
	}
	return (int) len;
}

/**
 *  @brief Removes double slashes in a path
 *
 *  e. g. "//a//b//c" will be converted to "a/b/c"
 *
 *  @param path   directory path
 */
void ftpRemoveDoubleSlash(char* path) {
	char *p;

	p = path;

	while (*p != '\0') {
		if ((p[0] == '/') && (p[1] == '/'))
			ftpStrcpy(p, &p[1]);
		else
			p++;
	}
}

/**
 *  @brief Merges multiple path strings
 *
 *  The function catenates all passed strings to a new string and assures that
 *  the result does not exceed MAX_PATH_LEN. The last parameter has to be
 *  NULL.
 *  Not all embedded environments support variadic functions, or they are
 *  too expensive.
 *
 *  @param dest    user name
 *
 *  @return Pointer to dest
 */
char* ftpMergePaths(char* dest, ...) {
	const char* src;
	char* dst = dest;
	int len = 0;
	va_list args;

	va_start(args, dest);

	while ((src = va_arg(args, const char*))) {
		while ((*src != '\0') && (len < MAX_PATH_LEN - 1)) {
			*dst++ = *src++;
			len++;
		}
	}

	*dst = '\0';
	va_end(args);

	return dst;
}

/**
 *  @brief Determine the unix-time
 *
 *  The function reads the clock from the target-layer and converts it to the
 *  unix-time. The code is taken from http://de.wikipedia.org/wiki/Unixzeit
 *
 *  @return seconds since 1. Januar 1970 00:00
 */
uint32_t ftpGetUnixTime(void) {
	ftpTime_S t;
	uint32_t unixTime = 0;
	int j;

	ftpGetLocalTime(&t);

	for (j = 1970; j < t.year; j++)              // leap years
	{
		if (j % 4 == 0 && (j % 100 != 0 || j % 400 == 0))
			unixTime += (366 * 24 * 60 * 60);
		else
			unixTime += (365 * 24 * 60 * 60);
	}
	for (j = 1; j < t.month; j++)                // days per month 31/30/29/28
	{
		if (j == 1 || j == 3 || j == 5 || j == 7 || j == 8 || j == 10 || j == 12)
			unixTime += (31 * 24 * 60 * 60);   		// months with 31 days
		if (j == 4 || j == 6 || j == 9 || j == 11)
			unixTime += (30 * 24 * 60 * 60);   		// months with 30 days
		if ((j == 2) && (t.year % 4 == 0 && (t.year % 100 != 0 || t.year % 400 == 0)))
			unixTime += (29 * 24 * 60 * 60);
		else
			unixTime += (28 * 24 * 60 * 60);
	}
	unixTime += ((t.day - 1) * 24 * 60 * 60);
	unixTime += (t.hour * 60 * 60);
	unixTime += t.minute * 60;
	unixTime += t.second;

	return unixTime;
}

/**
 *  @brief copy a string
 *
 *  The reason why feathery has its own strcpy is that in some cases src is
 *  part of dest and src > dest. Because ANSI-C explicitly declares that case
 *  as undefined our strcpy guarantees to copy from lower to higher
 *  addresses.
 *
 *  @param dest destination string
 *  @param src Null-terminated source string
 *
 *  @return destination string
 */
char *ftpStrcpy(char *dest, const char *src) {
	char       *d = dest;
	const char *s = src;

	while ((*d++ = *s++));
	return dest;
}