diff --git a/photosync.conf b/photosync.conf
new file mode 100644
index 0000000..ce941f3
--- /dev/null
+++ b/photosync.conf
@@ -0,0 +1,25 @@
+#!/bin/bash
+
+# Target server. Comment if target folder is on the same machine!
+TOSSH="192.168.0.5"
+# port to use for ssh on the server.
+SSHPORT=10110
+# User for the server.
+SSHUSER="myuser"
+# target folder on the server.
+SYNC_TARGET="/srv/Photos/"
+SYNC_EXTRA="/srv/Photos/duplicate/"
+
+# Extensions of the files to be copied.
+EXTENSIONS="*.jpg *.JPG *.mp4 *.MP4"
+
+# Prefixes replacing the to replace with 
+REPLACE="IMG VID";       # What to replace
+PREFIXES="USER USERVid"; # replace with
+
+# Max number of parallel copy processes.
+THRESHOLD=9
+
+# Overwrite the default log level of the photosync script.
+# Valid levels are LLDebug, LLInfo, LLWarning, LLError, LLMdtry, LLMute.
+Log_Level=$LLInfo
diff --git a/photosync.sh b/photosync.sh
index 26b0c5f..db3ac08 100755
--- a/photosync.sh
+++ b/photosync.sh
@@ -2,33 +2,44 @@
 ## Syncs all data in folder given to the configured destiny.
 
 ## Log levels for messages
-LLMUTE=0
-LLMDTRY=1
-LLERROR=2
-LLWARNING=3
-LLINFO=4
-LLDEBUG=5
+LLMute=0
+LLMdtry=1  # mandatory: messages that are always written to the log (except mute)
+LLError=2
+LLWarning=3
+LLInfo=4
+LLDebug=5
 ## Actual log level of the logger used
-LOGLEVEL=$LLDEBUG
+Log_Level=$LLDebug
 
 ## Write log of the script.
 ## $1 Loglevel to log the message with.
 ## $2 message to log.
-function __logger() {
-	local LOGGINGLEVEL=$1;
-	local LOGMESSAGE=$2;
-	local _NOW=$($DATE +%Y%m%d_%H:%M:%S);
-	if [[ $LOGLEVEL -ge $LOGGINGLEVEL ]]; then
-		echo "photosync $_NOW: ${LOGMESSAGE}" >> $LOGFILE;
+function logger() {
+	local _logging_level=$1;
+	local _log_message=$2;
+	if [[ $Log_Level -lt $_logging_level ]]; then
+		return;
 	fi
-	if [[ $LOGLEVEL -eq $LLDEBUG ]]; then
-		echo "photosync $_NOW: ${LOGMESSAGE}";
+	local _now=$($DATE +%Y%m%d_%H:%M:%S);
+	if [[ $_logging_level -eq $LLInfo ]]; then
+		_type=" Info:";
+	elif [[ $_logging_level -eq $LLError ]]; then
+		_type=" ERROR!";
+	elif [[ $_logging_level -eq $LLWarning ]]; then
+		_type=" Warning:";
+	elif [[ $_logging_level -eq $LLDebug ]]; then
+		_type=" DEBUG:";
+	else
+		_type=":";
+	fi
+	printf "photosync ${_now}${_type} ${_log_message}\n" >> $Log_File;
+	if [[ $Log_Level -eq $LLDebug ]]; then
+		printf "photosync ${_now}${_type} ${_log_message}\n";
 	fi
 }
 
 ## Display Help
-function __usage()
-{
+function usage() {
    echo "$0 syncs all data from a source folder to a target folder. Target folder may optionally be on a remote ssh server."
    echo
    echo "Syntax: scriptTemplate [-h|c|v|V]"
@@ -42,250 +53,264 @@ function __usage()
 
 ## Cleanup function to exit script gracefully
 # param1 Exit value to end with
-function __cleanup() {
-	local EXITVAL=$1
-	
-
-	exit $EXITVAL;
+function cleanup() {
+	logger $LLMdtry "Done! Exiting with value ${1}.";
+	exit $1;
 }
 
 ## Returns the binaries full path if existent.
 ## $1 referenced variable the found path to the binary is stored and returned in.
 ## $2 Name of the binary to look for.
 ## return 0 in case of success (binary found), 1 on fail. $1 then contains "$2 not found!".
-function __which_is() {
-	declare -n RETVAL=$1;
-	EXECUTABLE=$2;
-	WITHFULLPATH=$(which ${EXECUTABLE} 2>/dev/null);
-	if [ -x "$WITHFULLPATH" ]; then
-		RETVAL="$WITHFULLPATH";
+function which_is() {
+	declare -n _ret_val=$1;  # define _ret_val as a reference to the first parameter of the function.
+	local _executable=$2;
+	local _with_full_path=$(which ${_executable} 2>/dev/null);
+	if [ -x "$_with_full_path" ]; then
+		_ret_val="$_with_full_path";
 		return 0;
 	else
-		RETVAL="$EXECUTABLE not found!";
+		_ret_val="$_executable not found!";
 		return 1;
 	fi
 }
 
 ## Checks given folder for files with certain extensions. Subfolders are checked recursively. 
 ## $1 Folder to check.
-## $2 space separated list of extensions to check for. e.g.: "*.jpg *.JPG *.mp4 *.MP4".
+## $2 String of space separated extensions to check for. e.g.: "*.jpg *.JPG *.mp4 *.MP4".
 ## returns Count of files found with the desired extension.
-__check_folder() {
-	local _FOLDER=$1;
-	local _EXTENSIONS=$2;
-	local _FILE_C=0;
-	if [ -d "$_FOLDER" ]; then	# is a folder
-		local _ITEM="";
-		local _FC=${#FILESNPATHS[@]};
-		pushd "$_FOLDER" 1>/dev/null;
-		for _ITEM in ${_EXTENSIONS}; do # lookup all files with the desired extensions
-			if [[ -f "$_ITEM" ]]; then # is a file
-				FILESNPATHS[$_FC]="$(pwd)/$_ITEM";
- 				((_FC+=1));
- 				((_FILE_C+=1));
+function check_folder() {
+	local _folder=$1;
+	local _extensions=$2;
+	local _file_count=0;
+	if [ -d "$_folder" ]; then	# is a folder
+		local _item="";
+		local _fc=${#Files_N_Paths[@]};
+		pushd "$_folder" 1>/dev/null;
+		for _item in ${_extensions}; do # lookup all files with the desired extensions
+			if [[ -f "$_item" ]]; then # is a file
+				Files_N_Paths[$_fc]="$(pwd)/$_item";
+ 				((_fc+=1));
+ 				((_file_count+=1));
 			fi
 		done
 		# check subfolders if exist
-		local _SUBFOLDERS="$(/usr/bin/ls . 2>/dev/null)";
-		local _CNT=0;
-		for _SUBITEM in ${_SUBFOLDERS}; do
-			if [[ -d "$_SUBITEM" ]]; then
-				__check_folder "$_SUBITEM" "$_EXTENSIONS";
-				_CNT=$?
-				((_FILE_C+=_CNT));
+		local _sub_folders="$(/usr/bin/ls . 2>/dev/null)";
+		local _cnt=0;
+		for _sub_item in ${_sub_folders}; do
+			if [[ -d "$_sub_item" ]]; then
+				check_folder "$_sub_item" "$_extensions";
+				_cnt=$?
+				((_file_count+=_cnt));
 			fi
 		done
 		popd 1>/dev/null;
 	fi
-	return $_FILE_C
+	return $_file_count
 }
 
 ## Check filesizes of local and remote file
 ## $1 Path of local file
 ## $2 Path of remote file
+## return 0 in case of matching sizes, 1 means size differs, 2 remote file does not exist.
 check_local_remote_filesize() {
-	local LocalFile=$1;
-	local RemoteFile=$2;
-	local LocFileSize=$(stat -c%s "${LocalFile}");
-	__logger $LLDEBUG "Local file size  : $LocFileSize <${FILESNPATHS[$FILE_C]}>";
-	if [ -n $TOSSH ]; then
-		local RemFileSize=$($S $TOSSH "stat -c%s ${RemoteFile}" 2>/dev/null);
+	local _local_file=$1;
+	local _remote_file=$2;
+	local _local_file_size=$(stat -c%s "${_local_file}");
+	if [ ! -z $TOSSH ]; then
+		local _remote_file_size=$($S $TOSSH "stat -c%s ${_remote_file}" 2>/dev/null);
 	else
-		local RemFileSize=$(stat -c%s "${RemoteFile}");
+		local _remote_file_size=$(stat -c%s "${_remote_file}" 2>/dev/null);
 	fi
-	__logger $LLDEBUG "Remote file size : ${RemFileSize} <${TARGETPATH}/${FILEBASENAME}>";
-	if [[ $RemFileSize != ?(-)+([0-9]) ]]; then  # value should be integer to test true
-		__logger $LLERROR "Remote file »${RemoteFile}« does not exist!";
+	if [[ $_remote_file_size != ?(-)+([0-9]) ]]; then  # value should be integer to test true
 		return 2;
 	fi
-	if [ $LocFileSize -ne $RemFileSize ]; then
-		__logger $LLERROR "ERROR! Sizes of local and remote file size do not match! <${LocalFile}>!";
+	if [[ $_local_file_size -ne $_remote_file_size ]]; then
 		return 1;
 	fi
 	return 0;
 }
 
 ## Main function
-function __main() {
+function main() {
 
 	# create file list to move to copy to server
-	declare -A FILESNPATHS;  # associative array
-	__check_folder "$CPFOLDER" "$EXTENSIONS";
-	FILE_COUNT=$?
-	__logger $LLDEBUG "Count of files with extensions »$EXTENSIONS« is $FILE_COUNT.";
-	if [[ $FILE_COUNT -eq 0 ]]; then
-		__logger $LLERROR "No files to copy!"
-		__cleanup 1;
+	declare -A Files_N_Paths;  # associative array
+	check_folder "$Cp_Folder" "$EXTENSIONS";
+	local _file_count=$?
+	logger $LLDebug "Count of files with extensions »$EXTENSIONS« is $_file_count.";
+	if [[ $_file_count -eq 0 ]]; then
+		logger $LLError "No files to copy!"
+		cleanup 1;
 	fi
 	
 	# Make Lists for prefixes to replace
-	declare -A PREFIXES;
-	PRE_C=0;
-	for PRE in $PREFIX; do
-		PREFIXES[$PRE_C]="$PRE";  #echo "Arrayinhalt an der Stelle $INP_C: ${FILE[$INP_C]}";
-		((PRE_C=PRE_C+1));
+	declare -A _prefixes;
+	local _pre_c=0;
+	for _prefx in $PREFIXES; do
+		_prefixes[$_pre_c]="$_prefx";  #echo "Arrayinhalt an der Stelle $INP_C: ${FILE[$INP_C]}";
+		((_pre_c+=1));
 	done
-	if [ $PRE_C -eq 0 ]; then
-		__logger $LLERROR "ERROR! Number of prefixes ($PRE_C) must not be 0! Check variables in <$SOURCECONFFILE>!";
+	if [[ $_pre_c -eq 0 ]]; then
+		logger $LLError "Number of prefixes ($_pre_c) must not be 0! Check variables in <$Conf_File>!";
 		exit 1;
 	fi
 
 	# Make List with replacement prefixes
-	declare -A REPLACEMENTS;
-	REP_C=0;
-	for REP in $REPLACE; do
-		REPLACEMENTS[$REP_C]="$REP";
-		((REP_C=REP_C+1));
+	declare -A _replacements;
+	local _repl_c=0;
+	for _repl in $REPLACE; do
+		_replacements[$_repl_c]="$_repl";
+		((_repl_c+=+1));
 	done
-	if [ $REP_C -eq 0 ]; then
-		__logger $LLERROR "ERROR! Number of replacements ($REP_C) must not be 0! Check variables in <$SOURCECONFFILE>!";
+	if [[ $_repl_c -eq 0 ]]; then
+		logger $LLError "Number of replacements ($_repl_c) must not be 0! Check variables in <$Conf_File>!";
 		exit 1;
 	fi
-	if [ $REP_C -ne $PRE_C ]; then
-		__logger $LLERROR "ERROR! Number of prefixes ($PRE_C) is not equal to number of replacements ($REP_C)! Check variables in <$SOURCECONFFILE>!";
+	if [[ $_repl_c -ne $_pre_c ]]; then
+		logger $LLError "Number of prefixes ($_pre_c) is not equal to number of replacements ($_repl_c)! Check variables in <$Conf_File>!";
 		exit 1;
 	fi
 
-	__logger $LLMDTRY "_______________________ cloud_photosync.sh __________________________";
-	__logger $LLMDTRY "$($DATE '+%h:%n %d.%m.%Y')";
-	__logger $LLMDTRY "File count: $FILE_COUNT";
-	for((C=0;C<${#PREFIXES[*]};C++)); do
-		__logger $LLMDTRY "${PREFIXES[C]} -> ${REPLACEMENTS[C]}";
+	logger $LLMdtry "_______________________ ${0} __________________________";
+	logger $LLMdtry "$($DATE +'%h:%n %d.%m.%Y'), File count: $_file_count";
+	for((_pc=0;_pc<${#_prefixes[*]};_pc++)); do
+		logger $LLMdtry "${_prefixes[$_pc]} -> ${_replacements[$_pc]}";
 	done
 
+	local _succ_count=0;  # successfully copied files
+	local _done_count=0;	# files where already there
+	local _dup_diff=0;   # there already is a duplicate file
+	local _miss_count=0;	# after copy file sizes do not match
+	local _fail_count=0;  # file is missing after copy.
+
+	declare -A _original_files;
+	declare -A _date_times;
 	# Start copy loop
-	for((FILE_C=0;FILE_C<${#FILESNPATHS[*]};FILE_C++)); do	
+	for((_fc=0;_fc<${#Files_N_Paths[*]};_fc++)); do	
+
 		# we only start copying, when there are no more copy procedures ongoing, than THRESHOLD!
-		while [ ${#ORIGINALFILES[*]} -eq $THRESHOLD ]; do
-			__logger $LLDEBUG "$FILE_C Threshold reached.";
-			for CPID in "${!ORIGINALFILES[@]}"; do
-				if [ -n "${CPID}" -a -d "/proc/${CPID}" ]; then
-				 	# Prozess läuft noch, check nicht möglich   
-					__logger $LLDEBUG "${CPID} still running";
+		while [ ${#_original_files[*]} -eq $THRESHOLD ]; do  # as long as the length of original_files array is THRESHOLD
+			logger $LLDebug "$_fc Threshold reached.";
+			for _pid in "${!_original_files[@]}"; do	# check all process ids in _original_files
+				if [ -n "${_pid}" -a -d "/proc/${_pid}" ]; then
+				 	# Copy process still running   
+					logger $LLDebug "Copying of ${_original_files[$_pid]} (${_pid}) still running.";
 				else
-					# hochladen beendet, kann Größe testen
-					__logger $LLDEBUG "# Check on target ${TARGETFILES[$CPID]}";
-					check_local_remote_filesize "${ORIGINALFILES[$CPID]}" "${TARGETFILES[$CPID]}";
-					RET=$?;
-					if [ $RET -eq 0 ]; then # sizes match
+					# Copy process done, compare file sizes
+					logger $LLDebug "Check target »${_target_files[$_pid]}«";
+					check_local_remote_filesize "${_original_files[$_pid]}" "${_target_files[$_pid]}";
+					local _ret_clrfs=$?;
+					if [ $_ret_clrfs -eq 0 ]; then # sizes match
 						if [ ! -z "$TOSSH" ]; then  # otherwise cp is done with -p
-							FILEBASENAME=$(basename -- "${TARGETFILES[$CPID]}");
-							$S $TOSSH "touch -d '${DATETIMES[$CPID]}' ${TARGETFILES[$CPID]}"; # restore file creation date
+							local _file_base_name=$(basename -- "${_target_files[$_pid]}");
+							$S $TOSSH "touch -d '${_date_times[$_pid]}' ${_target_files[$_pid]}"; # restore file creation date
 						fi
-						((SUC_C=SUC_C+1))				
-						__logger $LLDEBUG "$SUC_C ${ORIGINALFILES[$CPID]}";
-					else	# sizes don't match or file does not exist
-						((MIS_C=MIS_C+1))				
+						((_succ_count+=1))				
+						logger $LLDebug "$SUC_C ${_original_files[$_pid]}";
+					elif [[ $_ret_clrfs -eq 1 ]]; then
+						logger $LLError "Sizes of local and remote file size do not match! »${_original_files[$_pid]}« <-> »${_target_files[$_pid]}«";
+						((_miss_count+=1))
+					else	# 2: file does not exist
+						logger $LLError "Remote file »${_target_files[$_pid]}« does not exist!";
+						((_fail_count+=1))				
 					fi
-					unset ORIGINALFILES["${CPID}"];
-					unset TARGETFILES["${CPID}"];
-					unset DATETIMES["${CPID}"];
+					unset _original_files["${_pid}"];
+					unset _target_files["${_pid}"];
+					unset _date_times["${_pid}"];
 				fi
-			done  # for CPID in "${!ORIGINALFILES[@]}"; do
+			done  # for _pid in "${!_original_files[@]}"; do
 		done
 
 		# set file creation date by exif date
-		DATETIME=$($EXIFTOOL -DateTimeOriginal -s -s -s -d '%F %H:%M:%S' "${FILESNPATHS[$FILE_C]}");
+		local _datetime=$($EXIFTOOL -DateTimeOriginal -s -s -s -d '%F %H:%M:%S' "${Files_N_Paths[$_fc]}");
 
 		# construct server path	
-		DATE_Y=$(date +%Y --date="$DATETIME");
-		DATE_M=$(date +%m --date="$DATETIME");
-		DATE_D=$(date +%d --date="$DATETIME");
-		# Targetpath format : YYYY/YYYY_MM_DD_PREFIX
-		TARGETPATH="${SYNC_TARGET}${DATE_Y}/${DATE_Y}_${DATE_M}_${DATE_D}_${PREFIXES[0]}"; # Path on server for target file
-		EXTRAPATH="${SYNC_EXTRA}${DATE_Y}/${DATE_Y}_${DATE_M}_${DATE_D}_${PREFIXES[0]}"; # Path on server for target file
-		__logger $LLDEBUG "Server target path »$TARGETPATH«";
+		local _date_y=$(date +%Y --date="$_datetime");
+		local _date_m=$(date +%m --date="$_datetime");
+		local _date_d=$(date +%d --date="$_datetime");
+		# _target_path format : YYYY/YYYY_MM_DD_PREFIX
+		_target_path="${SYNC_TARGET}${_date_y}/${_date_y}_${_date_m}_${_date_d}_${_prefixes[0]}"; # Path on server for target file
+		_extra_path="${SYNC_EXTRA}${_date_y}/${_date_y}_${_date_m}_${_date_d}_${_prefixes[0]}"; # Path on server for target file
+		logger $LLDebug "Server target path »$_target_path«";
 		
 		# create new file name
-		FILEBASENAME=$(basename -- "${FILESNPATHS[$FILE_C]}");
-		for((REPL_C=0;REPL_C<${#PREFIXES[*]};REPL_C++)); do
-			PREF="${PREFIXES[$REPL_C]}";
-			REPL="${REPLACEMENTS[$REPL_C]}";
-			FILEBASENAME="${FILEBASENAME/$REPL/$PREF}";
+		local _file_base_name=$(basename -- "${Files_N_Paths[$_fc]}");
+		for((_rc=0;_rc<${#_prefixes[*]};_rc++)); do
+			_pref="${_prefixes[$_rc]}";
+			_repl="${_replacements[$_rc]}";
+			_file_repl_name="${_file_base_name/$_repl/$_pref}";
 		done
+		logger $LLDebug "$_file_base_name -> $_file_repl_name";
 		# Test for existing files
-		check_local_remote_filesize "${FILESNPATHS[$FILE_C]}" "${TARGETPATH}/${FILEBASENAME}";
+		check_local_remote_filesize "${Files_N_Paths[$_fc]}" "${_target_path}/${_file_repl_name}";
 		CLRFSres=$?
-		if [ $CLRFSres -eq 0 ]; then
-			__logger $LLINFO "File <${FILESNPATHS[$FILE_C]}> already exists as <${TARGETPATH}/${FILEBASENAME}>, skipping.";
-		elif [ $CLRFSres -eq 1 ]; then  # file does not exist
+		if [ $CLRFSres -eq 0 ]; then  # file is already there
+ 			((_done_count+=1))
+			logger $LLInfo "File <${Files_N_Paths[$_fc]}> already exists as <${_target_path}/${_file_repl_name}>, skipping.";
+		elif [ $CLRFSres -eq 2 ]; then  # file does not exist, just start copy
 			if [ ! -z $TOSSH ]; then  #
-				__logger $LLINFO "Copying file <${FILESNPATHS[$FILE_C]}> -> Server<${TARGETPATH}/${FILEBASENAME}>";
-				cat "${FILESNPATHS[$FILE_C]}" | $S $TOSSH "mkdir -p ${TARGETPATH};cat > '${TARGETPATH}/${FILEBASENAME}'" &
-				COPYPID=$!;
+				logger $LLInfo "Copying file <${Files_N_Paths[$_fc]}> -> Server<${_target_path}/${_file_repl_name}>";
+				cat "${Files_N_Paths[$_fc]}" | $S $TOSSH "mkdir -p ${_target_path};cat > '${_target_path}/${_file_repl_name}'" &
+				_cp_pid=$!;
 			else  # no TOSSH
-				if [ ! -e "${TARGETPATH}" ]; then  # file path does not exist
-					mkdir -p "${TARGETPATH}";
+				if [ ! -e "${_target_path}" ]; then  # file path does not exist
+					mkdir -p "${_target_path}";
 				fi
-				if [ -d "${TARGETPATH}" ]; then
-					cp -p "${FILESNPATHS[$FILE_C]}" "${TARGETPATH}/${FILEBASENAME}" &
-					COPYPID=$!;
+				if [ -d "${_target_path}" ]; then
+					cp -p "${Files_N_Paths[$_fc]}" "${_target_path}/${_file_repl_name}" &
+					_cp_pid=$!;
 				else
-					__logger $LLERROR "Unable to create ${TARGETPATH}! Skipping file ${FILESNPATHS[$FILE_C]}!";
+					logger $LLError "Unable to create ${_target_path}! Skipping file ${Files_N_Paths[$_fc]}!";
 					continue;
 				fi
 			fi
-			ORIGINALFILES+=( ["${COPYPID}"]="${FILESNPATHS[$FILE_C]}" );
-			TARGETFILES+=( ["${COPYPID}"]="${TARGETPATH}/${FILEBASENAME}" );
-			DATETIMES+=(  ["${COPYPID}"]="${DATETIME}" );
-		else # 2: different size-> start copying
+			_original_files+=( ["${_cp_pid}"]="${Files_N_Paths[$_fc]}" );
+			_target_files+=( ["${_cp_pid}"]="${_target_path}/${_file_repl_name}" );
+			_date_times+=( ["${_cp_pid}"]="${_datetime}" );
+		else # 1: 
+			logger $LLInfo "Copying file <${Files_N_Paths[$_fc]}> to Server<${_extra_path}/${_file_repl_name}>; creating link to ${_target_path}/${_file_repl_name}.";
 			if [ ! -z $TOSSH ]; then  #
-				__logger $LLINFO "Copying file <${FILESNPATHS[$FILE_C]}> -> Server<${EXTRAPATH}/${FILEBASENAME}>";			
-				cat "${FILESNPATHS[$FILE_C]}" | $S $TOSSH "mkdir -p ${EXTRAPATH};cat > ${EXTRAPATH}/${FILEBASENAME} && ln -s ${TARGETPATH}/${FILEBASENAME} ${EXTRAPATH}/_${FILEBASENAME}" &
-				COPYPID=$!;
+				cat "${Files_N_Paths[$_fc]}" | $S $TOSSH "mkdir -p ${_extra_path};cat > ${_extra_path}/${_file_repl_name}" &
+				_cp_pid=$!;
+				$S $TOSSH "ln -s ${_target_path}/${_file_repl_name} ${_extra_path}/_${_file_repl_name}" &
 			else  # no TOSSH
-				if [ ! -e "${TARGETPATH}" ]; then  # path does not exist
-					mkdir -p "${TARGETPATH}";
+				if [ ! -e "${_extra_path}" ]; then  # path does not exist
+					mkdir -p "${_extra_path}";
 				fi
-				if [ -d "${TARGETPATH}" ]; then  # check if target path exists as folder
-					cp -p "${FILESNPATHS[$FILE_C]}" "${TARGETPATH}/${FILEBASENAME}" &
-					COPYPID=$!;
+				if [ -d "${_extra_path}" ]; then  # check if target path exists as folder
+					cp -p "${Files_N_Paths[$_fc]}" "${_extra_path}/${_file_repl_name}" &
+					_cp_pid=$!;
+					ln -s "${_target_path}/${_file_repl_name}" "${_extra_path}/_${_file_repl_name}" &
 				else
-					__logger $LLERROR "Unable to create ${TARGETPATH}! Skipping file ${FILESNPATHS[$FILE_C]}!";
+					logger $LLError "Unable to create ${_extra_path}! Skipping file ${Files_N_Paths[$_fc]}!";
+					((_miss_count+=1))
 					continue;
 				fi
 			fi
-			ORIGINALFILES+=( ["${COPYPID}"]="${FILESNPATHS[$FILE_C]}" );
-			TARGETFILES+=( ["${COPYPID}"]="${TARGETPATH}/${FILEBASENAME}" );
-			DATETIMES+=( ["${COPYPID}"]="${DATETIME}" );
+			((_dup_diff+=1))			
+			_original_files+=( ["${_cp_pid}"]="${Files_N_Paths[$_fc]}" );
+			_target_files+=( ["${_cp_pid}"]="${_target_path}/${_file_repl_name}" );
+			_date_times+=( ["${_cp_pid}"]="${_datetime}" );
 		fi
 
-	done  # Start copy loop
+	done  # copy loop
+	logger $LLMdtry "Tried to copy $_file_count files.\n$_done_count where already there,\n$_succ_count where copied of which $_dup_diff where of different size and got copied to the extra location,\n$_miss_count have different size after copy and\n$_fail_count could not be copied.";
 }  ## end main
 
 
 # Get the options from commandline
-while getopts ":hc:f:" option 2>/dev/null; do
-	case $option in
+while getopts ":hc:f:" Option 2>/dev/null; do
+	case $Option in
 		h) # display Help
-			__usage
-			__cleanup 1
+			usage
+			cleanup 1
 			;;
 		c) # configuration file to use
-			CONFFILE=$OPTARG;			
+			Conf_File=$OPTARG;			
 			;;
 		f) # folder to copy
-			CPFOLDER=$OPTARG;
+			Cp_Folder=$OPTARG;
 			;;
 		\?)
 			echo "Invalid option: -$OPTARG";
@@ -297,81 +322,78 @@ while getopts ":hc:f:" option 2>/dev/null; do
 	esac
 done
 
-if [[ -z "$CONFFILE" ]]; then
+if [[ -z "$Conf_File" ]]; then
 	echo "The option -c is mandatory! Provide a configuration file!";
-	__cleanup 1;
+	cleanup 1;
 fi
-if [[ -f "${CONFFILE}" ]]; then
-	echo "Using configuration file $CONFFILE.";
-	source $CONFFILE;
+if [[ -f "${Conf_File}" ]]; then
+	echo "Using configuration file $Conf_File.";
+	source $Conf_File;
 else
-	echo "ERROR: $CONFFILE is not a file!";
-	__cleanup 1;
+	echo "ERROR: $Conf_File is not a file!";
+	cleanup 1;
 fi
 
-if [[ -z "$CPFOLDER" ]]; then
+if [[ -z "$Cp_Folder" ]]; then
 	echo "The option -f is mandatory! Provide a folder to copy!";
-	__cleanup 1;
+	cleanup 1;
 fi
-if [[ -d "${CPFOLDER}" ]]; then
-	echo "Copying folder $CPFOLDER.";
+if [[ -d "${Cp_Folder}" ]]; then
+	echo "Copying folder $Cp_Folder.";
 else
-	echo "ERROR: $CPFOLDER is not a folder!";
-	__cleanup 1;
+	echo "ERROR: $Cp_Folder is not a folder!";
+	cleanup 1;
 fi
 
 ## Check binaries availability
-__which_is SUDO 'sudo';
+which_is SUDO 'sudo';
 if [ $? -ne 0 ]; then echo $SUDO; exit 1; fi
 
-__which_is DATE 'date';
+which_is DATE 'date';
 if [ $? -ne 0 ]; then echo $DATE; exit 1; fi
 
-__which_is LN 'ln';
+which_is LN 'ln';
 if [ $? -ne 0 ]; then echo $LN; exit 1; fi
 
-__which_is RM 'rm';
+which_is RM 'rm';
 if [ $? -ne 0 ]; then echo $RM; exit 1; fi
 
-__which_is SSH 'ssh';
+which_is SSH 'ssh';
 if [ $? -ne 0 ]; then echo $SSH; exit 1; fi
 
-__which_is TOUCH 'touch';
+which_is TOUCH 'touch';
 if [ $? -ne 0 ]; then echo $TOUCH; exit 1; fi
 
-__which_is CHOWN 'chown';
+which_is CHOWN 'chown';
 if [ $? -ne 0 ]; then echo $CHOWN; exit 1; fi
 
-__which_is EXIFTOOL 'exiftool';
+which_is EXIFTOOL 'exiftool';
 if [ $? -ne 0 ]; then echo $EXIFTOOL; exit 1; fi
 
-__which_is NC 'nc';
+which_is NC 'nc';
 if [ $? -ne 0 ]; then echo $NC; exit 1; fi
 
-RUNDATE=$($DATE +%Y_%m_%d)
-LOGFILE="/tmp/${RUNDATE}_photosync.log";
+Run_Date=$($DATE +%Y_%m_%d)
+Log_File="/tmp/${Run_Date}_photosync.log";
 
 # Check if target is on remote server (TOSSH nonzero length)
 if [ ! -z $TOSSH ]; then
-	__logger $LLDEBUG "Will copy to »$TOSSH«!";
+	logger $LLDebug "Will copy to »$TOSSH«!";
   # Check validity of ssh data
   if [ "$SSHUSER" ] && [ "$SSHPORT" ]; then
     S="$SSH -p $SSHPORT -l $SSHUSER";
   else
-    __logger $LLERROR "Invalid ssh command, port or user: »$SSH« »$SSHPORT« «$SSHUSER«";
-    __cleanup 1;
+    logger $LLError "Invalid ssh command, port or user: »$SSH« »$SSHPORT« «$SSHUSER«";
+    cleanup 1;
   fi
   # Check availability of target server
   $NC -z -w1 $TOSSH $SSHPORT > /dev/null
   if [ $? -ne 0 ]; then
-    __logger $LLERROR "The server $TOSSH is not reachable.";
-    __cleanup 1;
+    logger $LLError "The server $TOSSH is not reachable.";
+    cleanup 1;
   fi
 fi
 
-RUNDATE=$($DATE +%Y_%m_%d)
-LOGFILE="/tmp/${RUNDATE}_cloud_photosync.log";
-
 # Add slash to paths if missing
 if [ "${SYNC_TARGET:${#SYNC_TARGET}-1:1}" != "/" ]; then
   SYNC_TARGET=$SYNC_TARGET/
@@ -386,4 +408,6 @@ if [ "${CONFIG_NC_LOGPATH:${#CONFIG_NC_LOGPATH}-1:1}" != "/" ]; then
 fi
 # run the program after basics where checked.
 
-__main
+main
+
+cleanup 0;