Attachment #33406 for bug #53638




Please read the IMPORTANT NOTE on xMule's versioning system below!
For changes to the UNSTABLE branch, see ChangeLog-UNSTABLE.
Version 1.8.2d
--------------
*New in 1.8.2d
     *ADDED: Dynamic Partfiles (named as x.pnew and x.pnew.met instead of x.part and x.part.met)
	     This type of partfiles needs only as much space on disk as downloaded, not as the filesize tells
	     Its possible, to use both types with the some xmule at the same time (to finish older downloads)
     *ADDED: Renewable Clienthash on startup (to increase security) (to activate look at FlowChart
     *ADDED: Configureoption "--enable-cryptopp" to use the original library instead of the far more
	     compact CryptoXMpp for compatibility reasons (on 64-Bitsystems and other than i386).
*Bugfixes
     *FIXED: Corrected version-information for xmule (Thanks to Kry from aMule team to inform us
	     about that!) for CT_VERSION_MOD on SendHelloTypePacket in BaseClient.cpp.
     *FIXED: Clienthash now saved and loaded
	     
Version 1.8.2c
--------------
2004-06-01




Otherwise, you will miss some popup-menues inside the FlowChart-Window, which are needed to enable functions
like "source-exchange" and "securehash/ident/creditfiles".

===========================================================================================================
NEW: Overview to install all needed libs from scratch under problematic conditions (suse/mandrake/fc2/etc):
=========================================english===========================================================
You will need: 

autoconf-2.59 (min. see autoconf --version) 
gettext-0.11.5 (min. see gettext --version) 
automake-1.7.9 (min. see automake --version) 
glib-1.2.10 
gtk-1.2.10 
wxGTK-2.4.2 (no unicode, to configure with --with-gtk 
--disable-gtk2) 
xMule-1.8.2c 


To download: 

cd /usr/src 
wget ftp://ftp.gnu.org/gnu/autoconf/autoconf-2.59.tar.gz 
wget ftp://ftp.gnu.org/gnu/gettext/gettext-0.11.5.tar.gz 
wget ftp://ftp.gnu.org/gnu/automake/automake-1.7.9.tar.gz 
wget ftp://ftp.nctu.edu.tw/UNIX/gtk/v1.2/glib-1.2.10.tar.gz 
wget ftp://ftp.nctu.edu.tw/UNIX/gtk/v1.2/gtk+-1.2.10.tar.gz 
wget 
http://heanet.dl.sourceforge.net/sourceforge/wxwindows/wxGTK-2.4.2.tar.gz 
wget http://download.gna.org/xmule/xmule-1.8.2c.tar.gz 

To install: 

cd /usr/src 
tar zxvf autoconf*.gz 
tar zxvf gettext*.gz 
tar zxvf automake*.gz 
tar zxvf glib*.gz 
tar zxvf gtk*.gz 
tar zxvf wxGTK*.gz 
tar zxvf xmule*.gz 

cd /usr/src/autoconf*9 
./configure 
make 
make install 

cd /usr/src/gettext*5 
./configure 
make 
make install 

cd /usr/src/automake*9 
./configure 
make 
make install 

vi /etc/ld.so.conf 
>>>>insert the following lines if not exist: 
/usr/local/lib 
/usr/local/lib/glib-1.2 
/usr/local/lib/gtk-1.2 

cd /usr/src/glib*10 
./configure 
make 
make install 
ldconfig 

cd /usr/src/gtk*10 
./configure 
make 
make install 
ldconfig 

cd /usr/src/wxGTK*2 
./configure --with-gtk --disable-gtk2 
make 
make install 
ldconfig 

cd /usr/src/xmule*2c 
./configure --enable-debug 
make 
cp /usr/src/xmule*2c/src/xmule /usr/bin 
chmod 755 /usr/bin/xmule 

For every user-account ($HOME) you wish to use xMule, you 
have to do the following: 

mkdir $HOME/.xMule 
chmod 777 $HOME/.xMule 
cp -R /usr/src/xmule*2c/src/resource $HOME/.xMule 
chmod 755 $HOME/.xMule/resource 

That's all!
===========================================================================================================
NEW: Übersicht um alle benötigten Libraries zu installieren unter erschwerten Bedingungen/ohne Kentnisse:
=========================================deutsch===========================================================
Benötigt dazu werden nur (alle selbst zu kompilieren, in dieser Reihenfolge - in 30 Minuten erledigt): 

autoconf-2.59 (mindestens, siehe autoconf --version) 
gettext-0.11.5 (mindestens, siehe gettext --version) 
automake-1.7.9 (mindestens, siehe automake --version) 
glib-1.2.10 
gtk-1.2.10 
wxGTK-2.4.2 (kein Unicode, configured mit --with-gtk --disable-gtk2) 
xMule-1.8.2c 

Zur Vorbereitung: 

Yast2 starten, Software installieren/deinstallieren, Suche: 

glib -> eventuell installierte Pakete glib-1.2.10 & -devel löschen 
gtk -> eventuell installierte Pakete gtk+-1.2.10 & -devel löschen 
wxGTK-2.4.1 -> falls installiert, löschen 

Yast2 verlassen. 

Zum Download: 

cd /usr/src 
wget <ftp://ftp.gnu.org/gnu/autoconf/autoconf-2.59.tar.gz> 
wget <ftp://ftp.gnu.org/gnu/gettext/gettext-0.11.5.tar.gz> 
wget <ftp://ftp.gnu.org/gnu/automake/automake-1.7.9.tar.gz> 
wget <ftp://ftp.nctu.edu.tw/UNIX/gtk/v1.2/glib-1.2.10.tar.gz> 
wget <ftp://ftp.nctu.edu.tw/UNIX/gtk/v1.2/gtk+-1.2.10.tar.gz> 
wget <http://heanet.dl.sourceforge.net/sourceforge/wxwindows/wxGTK-2.4.2.tar.gz> 
wget <http://download.gna.org/xmule/xmule-1.8.2c.tar.gz> 

Zur Installation: 

cd /usr/src 
tar zxvf autoconf*.gz 
tar zxvf gettext*.gz 
tar zxvf automake*.gz 
tar zxvf glib*.gz 
tar zxvf gtk*.gz 
tar zxvf wxGTK*.gz 
tar zxvf xmule*.gz 

cd /usr/src/autoconf*9 
./configure 
make 
make install 

cd /usr/src/gettext*5 
./configure 
make 
make install 

cd /usr/src/automake*9 
./configure 
make 
make install 

vi /etc/ld.so.conf 
>>>>folgende Zeilen eintragen (falls keine solche vorhanden) 
/usr/local/lib 
/usr/local/lib/glib-1.2 
/usr/local/lib/gtk-1.2 

cd /usr/src/glib*10 
./configure 
make 
make install 
ldconfig 

cd /usr/src/gtk*10 
./configure 
make 
make install 
ldconfig 

cd /usr/src/wxGTK*2 
./configure --with-gtk --disable-gtk2 
make 
make install 
ldconfig 

cd /usr/src/xmule*2c 
./configure --enable-debug 
make 
cp /usr/src/xmule*2c/src/xmule /usr/bin 
chmod 755 /usr/bin/xmule 

Für jeden Benutzeraccount ($HOME) notwendig, für den man xMule verwenden möchte: 

mkdir $HOME/.xMule 
chmod 777 $HOME/.xMule 
cp -R /usr/src/xmule*2c/src/resource $HOME/.xMule 
chmod 755 $HOME/.xMule/resource 

Das war alles!




v1.8.x TODO:
------------
priority,status,info
1,open: new functions to convert partfiles from and to new-format
1,open: serverless-runmode for xmule
2,open: priorities-bugfix & optimization for downloadtable
3,open: xmule-icon-only instead of minimized in toolbar & icon at the same time
3,open: encryption of partfiles and sharedfiles for only being decrypted while xmule is running with the
.......correct privatekey. publickey will be endless (for every byte/character enother encoding-base)
.......so only who knows the privatekey is able to decrypt the encrypted date and this only while xmule
.......is running - so no further filesystem-encryption will be needed after xmule encrypted all files
.......in itself on disk.
.......the encrypted files could be burned to dvd or cd - the length of the files will be the same
.......(encrypted or decrypted)
.......encrypted files on dvd/cdr will be usable/accessible after an additional decryption over xmule to disk
.......
.......the private key will not be stored anywhere
.......the private key will be the key to enter xmule in the future - everyone can define the privatekey for
.......itself on every start. if the privatekey on start is another than on the last start of xmule,
.......all files not encrypted with the actual privatekey will not be accessible/usable
.......
.......the encryption-algorithm will be a completely new one - never used before. so there will be no
.......other program at the moment which will be able to decrypt the files encrypted by xmule other than
.......xmule itself
.......
.......this means: you should never forget your privatekey, otherwise all files encrypted with this key
...................will be lost forever




#! /bin/sh
# Guess values for system-dependent variables and create Makefiles.
# Generated by GNU Autoconf 2.59 for xMule 1.8.2d.
#
# Report bugs to <http://xmule.hopto.org/board/>.
#

# Identity of this package.
PACKAGE_NAME='xMule'
PACKAGE_TARNAME='xmule'
PACKAGE_VERSION='1.8.2d'
PACKAGE_STRING='xMule 1.8.2d'
PACKAGE_BUGREPORT='http://xmule.hopto.org/board/'

ac_unique_file="src/SharedFileList.h"

  # Omit some internal or obsolete options to make the list less imposing.
  # This message is too long to be a string in the A/UX 3.1 sh.
  cat <<_ACEOF
\`configure' configures xMule 1.8.2d to adapt to many kinds of systems.

Usage: $0 [OPTION]... [VAR=VALUE]...



if test -n "$ac_init_help"; then
  case $ac_init_help in
     short | recursive ) echo "Configuration of xMule 1.8.2d:";;
   esac
  cat <<\_ACEOF


  --disable-gtktest       Do not try to compile and run a test GTK program
  --enable-debug          Enable additional debugging output
  --disable-debug-syms    Disable debugging information
  --enable-cryptopp       Enable use of libcryptopp.a instead of CryptoXMpp
  --enable-optimise       Enable code optimising
  --enable-profile        Enable code profiling
  --disable-gtk           Disable pure GTK code in xmule

test -n "$ac_init_help" && exit 0
if $ac_init_version; then
  cat <<\_ACEOF
xMule configure 1.8.2d
generated by GNU Autoconf 2.59

Copyright (C) 2003 Free Software Foundation, Inc.

This file contains any messages produced by compilers while
running configure, to aid debugging if configure makes a mistake.

It was created by xMule $as_me 1.8.2d, which was
generated by GNU Autoconf 2.59.  Invocation command line was

  $ $0 $@





          ac_config_headers="$ac_config_headers config.h"

          ac_config_commands="$ac_config_commands default-1"


# BEGIN COMPAT VARIABLES




cat >>confdefs.h <<\_ACEOF
#define VERSION "1.8.2d"
_ACEOF

PACKAGE="xmule"
VERSION="1.8.2d"


# END COMPAT VARIABLES

        rm -f messages.po
  fi

            ac_config_commands="$ac_config_commands default-2"


# Make sure we can run config.sub.

  USE_DEBUG_SYMS="yes"
fi;

# Check whether --enable-cryptopp or --disable-cryptopp was given.
if test "${enable_cryptopp+set}" = set; then
  enableval="$enable_cryptopp"

fi;

# Check whether --enable-optimise or --disable-optimise was given.
if test "${enable_optimise+set}" = set; then
  enableval="$enable_optimise"

   esac
fi

if test -n "$enable_cryptopp"; then
   enable_cryptopp=no
   CRDEFS="-D__CRPP__"
   LIBCRPP="-lcryptopp"
else
   CRDEFS=""
fi


if test -n "$enable_gtk"; then
   enable_stripgtk=no
   GTK_DEFS="-D__NOGTK__"


# we have it anyway by now

LIBS="$LIBS $WX_LIBS $ZLIB_LIBS $LIBM $LIBCRPP"

GTK_CFLAGS="$GTK_CFLAGS $CRDEFS"
PCHFLAGS="$PCHFLAGS $DEBUG_FLAGS $GTK_CFLAGS -I. $DEFS $WX_CXXFLAGS"




XRCFLAGS="-Isrc"
CXXFLAGS="$CXXFLAGS $OPTIMISE_FLAGS $PROFILE_FLAGS $WX_CXXFLAGS $GTK_CFLAGS $XRCFLAGS $ZLIB_CFLAGSx"
CFLAGS="$GTK_DEFS $CXXFLAGS $OPTIMISE_FLAGS $PROFILE_FLAGS"
LDFLAGS="$EXPORT_DYN_FLAGS $PROFILE_FLAGS $LDFLAGS"

                                                            ac_config_files="$ac_config_files src/Makefile intl/Makefile po/Makefile.in src/wx/xrc/Makefile Makefile Compilation.flags"

} >&5
cat >&5 <<_CSEOF

This file was extended by xMule $as_me 1.8.2d, which was
generated by GNU Autoconf 2.59.  Invocation command line was

  CONFIG_FILES    = $CONFIG_FILES


cat >>$CONFIG_STATUS <<_ACEOF
ac_cs_version="\\
xMule config.status 1.8.2d
configured by $0, generated by GNU Autoconf 2.59,
  with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"


# INIT-COMMANDS section.
#


# Capture the value of obsolete ALL_LINGUAS because we need it to compute
    # POFILES, GMOFILES, UPDATEPOFILES, DUMMYPOFILES, CATALOGS. But hide it
    # from automake.

  "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
  "Compilation.flags" ) CONFIG_FILES="$CONFIG_FILES Compilation.flags" ;;
  "default-1" ) CONFIG_COMMANDS="$CONFIG_COMMANDS default-1" ;;
  "default-2" ) CONFIG_COMMANDS="$CONFIG_COMMANDS default-2" ;;
  "config.h" ) CONFIG_HEADERS="$CONFIG_HEADERS config.h" ;;
  *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
echo "$as_me: error: invalid argument: $ac_config_target" >&2;}

  { echo "$as_me:$LINENO: executing $ac_dest commands" >&5
echo "$as_me: executing $ac_dest commands" >&6;}
  case $ac_dest in
    default-1 ) test -z "$CONFIG_HEADERS" || echo timestamp > stamp-h ;;
    default-2 )
    for ac_file in $CONFIG_FILES; do
      # Support "outfile[:infile[:infile...]]"
      case "$ac_file" in

Lines 1-13 Link Here

(-)xmule/configure.in (-5 / +17 lines)
1	# Process this file with autoconf to produce a configure script.	1	# Process this file with autoconf to produce a configure script.
2	AC_INIT([xMule],[1.8.2c],[http://xmule.hopto.org/board/])	2	AC_INIT([xMule],[1.8.2d],[http://xmule.hopto.org/board/])
3	AC_CONFIG_SRCDIR([src/SharedFileList.h])	3	AC_CONFIG_SRCDIR([src/SharedFileList.h])
4	AM_CONFIG_HEADER([config.h])	4	AM_CONFIG_HEADER([config.h])
5		5
6	# BEGIN COMPAT VARIABLES	6	# BEGIN COMPAT VARIABLES
7	AC_DEFINE(PACKAGE, ["xmule"], [Description])	7	AC_DEFINE(PACKAGE, ["xmule"], [Description])
8	AC_DEFINE(VERSION, ["1.8.2c"], [Description])	8	AC_DEFINE(VERSION, ["1.8.2d"], [Description])
9	PACKAGE="xmule"	9	PACKAGE="xmule"
10	VERSION="1.8.2c"	10	VERSION="1.8.2d"
11	AC_SUBST(PACKAGE)	11	AC_SUBST(PACKAGE)
12	AC_SUBST(VERSION)	12	AC_SUBST(VERSION)
13	# END COMPAT VARIABLES	13	# END COMPAT VARIABLES
Lines 64-69 Link Here
64	AC_ARG_ENABLE(debug, [ --disable-debug-syms Disable debugging information],	64	AC_ARG_ENABLE(debug, [ --disable-debug-syms Disable debugging information],
65	USE_DEBUG_SYMS="$disableval", USE_DEBUG_SYMS="yes")	65	USE_DEBUG_SYMS="$disableval", USE_DEBUG_SYMS="yes")
66		66
		67	AC_ARG_ENABLE(cryptopp, [ --enable-cryptopp Enable use of libcryptopp.a instead of CryptoXMpp])
		68
67	AC_ARG_ENABLE(optimise,[ --enable-optimise Enable code optimising],	69	AC_ARG_ENABLE(optimise,[ --enable-optimise Enable code optimising],
68	USE_OPTIMISE="$enableval", USE_OPTIMISE="no")	70	USE_OPTIMISE="$enableval", USE_OPTIMISE="no")
69		71
Lines 146-151 Link Here
146	esac	148	esac
147	fi	149	fi
148		150
		151	if test -n "$enable_cryptopp"; then
		152	enable_cryptopp=no
		153	CRDEFS="-D__CRPP__"
		154	LIBCRPP="-lcryptopp"
		155	else
		156	CRDEFS=""
		157	fi
		158
		159
149	if test -n "$enable_gtk"; then	160	if test -n "$enable_gtk"; then
150	enable_stripgtk=no	161	enable_stripgtk=no
151	GTK_DEFS="-D__NOGTK__"	162	GTK_DEFS="-D__NOGTK__"
Lines 168-175 Link Here
168	AC_DEFINE_UNQUOTED(LOCALEDIR, "`eval echo $datadir/locale`", [Define where the locales are.])	179	AC_DEFINE_UNQUOTED(LOCALEDIR, "`eval echo $datadir/locale`", [Define where the locales are.])
169	# we have it anyway by now	180	# we have it anyway by now
170		181
171	LIBS="$LIBS $WX_LIBS $ZLIB_LIBS $LIBM"	182	LIBS="$LIBS $WX_LIBS $ZLIB_LIBS $LIBM $LIBCRPP"
172		183
		184	GTK_CFLAGS="$GTK_CFLAGS $CRDEFS"
173	PCHFLAGS="$PCHFLAGS $DEBUG_FLAGS $GTK_CFLAGS -I. $DEFS $WX_CXXFLAGS"	185	PCHFLAGS="$PCHFLAGS $DEBUG_FLAGS $GTK_CFLAGS -I. $DEFS $WX_CXXFLAGS"
174		186
175	AC_SUBST(GTK_DEFS)	187	AC_SUBST(GTK_DEFS)
Lines 178-184 Link Here
178	AC_SUBST(MAKE_PRECOMP)	190	AC_SUBST(MAKE_PRECOMP)
179	XRCFLAGS="-Isrc"	191	XRCFLAGS="-Isrc"
180	CXXFLAGS="$CXXFLAGS $OPTIMISE_FLAGS $PROFILE_FLAGS $WX_CXXFLAGS $GTK_CFLAGS $XRCFLAGS $ZLIB_CFLAGSx"	192	CXXFLAGS="$CXXFLAGS $OPTIMISE_FLAGS $PROFILE_FLAGS $WX_CXXFLAGS $GTK_CFLAGS $XRCFLAGS $ZLIB_CFLAGSx"
181	CFLAGS="$GTK_DEFS $CFLAGS $CXXFLAGS $OPTIMISE_FLAGS $PROFILE_FLAGS"	193	CFLAGS="$GTK_DEFS $CXXFLAGS $OPTIMISE_FLAGS $PROFILE_FLAGS"
182	LDFLAGS="$EXPORT_DYN_FLAGS $PROFILE_FLAGS $LDFLAGS"	194	LDFLAGS="$EXPORT_DYN_FLAGS $PROFILE_FLAGS $LDFLAGS"
183		195
184	AC_CONFIG_FILES([src/Makefile intl/Makefile po/Makefile.in src/wx/xrc/Makefile Makefile Compilation.flags])	196	AC_CONFIG_FILES([src/Makefile intl/Makefile po/Makefile.in src/wx/xrc/Makefile Makefile Compilation.flags])




#	include "KnownFile.h"
#	include "opcodes.h"
#	include "otherfunctions.h"
#	include "PartFile.h"
#	include "types.h"
#	include "xmule.h"
#	include "xmuleDlg.h"

void CAddFileThread:: Shutdown()
{
    m_lockWaitingForHashList.Lock();
#if defined(__DEBUG__)
    printf("Signaling hashing thread to terminate\n");
#endif
    // Tell the thread to exit
    m_endWaitingForHashList = 1;
    // Signal the thread there is something to do

        UnknownFile_Struct *hashfile = m_sWaitingForHashList.RemoveHead();
        m_lockWaitingForHashList.Unlock();
        CKnownFile *newrecord = new CKnownFile();
        newrecord -> CreateFromFile(hashfile->owner,hashfile -> directory, hashfile -> name, 
			&m_endWaitingForHashList);
        newrecord -> CreateFromFile(hashfile -> directory, hashfile -> name, &m_endWaitingForHashList);
        if (!m_endWaitingForHashList)
        {
            wxCommandEvent evt(wxEVT_COMMAND_MENU_SELECTED, TM_FINISHEDHASHING);





void CUpDownClient:: SendHelloTypePacket(CMemFile *data)
{
/*
unsigned char *uh;
uh=(unsigned char *)theApp.glob_prefs->GetUserHash();
for(int i=0;i<16;i++) {
printf("  %02x",uh[i]);
}
printf("\n");
*/

    data -> Write(theApp.glob_prefs -> GetUserHash(), 16);
    uint32 clientid = theApp.serverconnect -> GetClientID();
    data -> Write( &clientid, 4);

    tagVersion.WriteTagToFile(data);
    CTag tagUDPports(CT_EMULE_UDPPORTS, (uint32) theApp.glob_prefs -> GetUDPPort());
    tagUDPports.WriteTagToFile(data);
    if(!newprefs01_opt[3]) {
    	CTag tagMuleVersion(CT_EMULE_VERSION, 
		(SO_XMULE << 24)|(VERSION_MJR<<17)|(VERSION_MIN<<10)|(VERSION_UPDATE<<7));
        tagMuleVersion.WriteTagToFile(data);
    } else {
    	CTag tagMuleVersion(CT_EMULE_VERSION, 
		(SO_EMULE << 24)|(0<<17)|(42<<10)|(VERSION_UPDATE<<4));
    tagMuleVersion.WriteTagToFile(data);
    }
    const uint32 uUdpVer = 4;
    const uint32 uDataCompVer = 1;
    const uint32 uSupportSecIdent = theApp.clientcredits -> CryptoAvailable() ?3: 0;


int CUpDownClient:: GetHashType()
{
    int retcode=0;
    if (m_achUserHash[5] == 13 &&m_achUserHash[14] == 110) {
      retcode=SO_OLDEMULE;
    } else if(m_achUserHash[5] == 14 &&m_achUserHash[14] == 111) {
      retcode=SO_EMULE;
    } else if(m_achUserHash[5] == 'M' &&m_achUserHash[14] == 'L') {
      retcode=SO_MLDONKEY;
    } else {
      retcode=SO_UNKNOWN;
    }
    return retcode;
}

void CUpDownClient:: SetUserName(char *pszNewName)

Lines 19-26 Link Here

(-)xmule/src/ClientCredits.cpp (-3 / +2 lines)
19	//along with this program; if not, write to the Free Software	19	//along with this program; if not, write to the Free Software
20	//Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.	20	//Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21		21
22	//#ifdef PRECOMP	22	#ifdef PRECOMP
23	#if 1
24	# include "xmule-headers.h"	23	# include "xmule-headers.h"
25	#else	24	#else
26	# include "ClientCredits.h"	25	# include "ClientCredits.h"
Lines 42-48 Link Here
42	#include <fcntl.h>	41	#include <fcntl.h>
43	#include <wx/utils.h>	42	#include <wx/utils.h>
44		43
45	#if 1	44	#ifndef __CRPP__
46	# include "CryptoXMpp.h"	45	# include "CryptoXMpp.h"
47	#else	46	#else
48	# include <cryptopp/config.h>	47	# include <cryptopp/config.h>




#include "Preferences.h"
#include "MapKey.h"

#ifdef __CRPP__
#	include "CryptoXMpp.h"
#else
#	include	<cryptopp/cryptlib.h>
#	include	<cryptopp/rsa.h>
#define CryptoXMpp		CryptoPP
#else
#	include "CryptoXMpp.h"
#endif

/* winemaker: #pragma pack(1) */

Lines 59-64 Link Here

(-)xmule/src/CryptoXMpp.cpp (-1 / +2 lines)
59	only the for xmule needed parts taken from cryptopp in 2004 by upload2010	59	only the for xmule needed parts taken from cryptopp in 2004 by upload2010
60	*/	60	*/
61		61
		62	#ifndef __CRPP__
62	#include <errno.h>	63	#include <errno.h>
63	#include <fcntl.h>	64	#include <fcntl.h>
64	#include <iomanip>	65	#include <iomanip>
Lines 9371-9374 Link Here
9371	}	9372	}
9372		9373
9373	}	9374	}
9374		9375	#endif

Lines 72-77 Link Here

(-)xmule/src/CryptoXMpp.h (+2 lines)
72	only the for xmule needed parts taken from cryptopp in 2004 by upload2010	72	only the for xmule needed parts taken from cryptopp in 2004 by upload2010
73	*/	73	*/
74		74
		75	#ifndef __CRPP__
75	#ifndef CRYPTOPP_CONFIG_H	76	#ifndef CRYPTOPP_CONFIG_H
76	#define CRYPTOPP_CONFIG_H	77	#define CRYPTOPP_CONFIG_H
77		78
Lines 9440-9442 Link Here
9440	}	9441	}
9441		9442
9442	#endif	9443	#endif
		9444	#endif





extern int newprefs03_opt[];

CBarShader CUpDownClient::s_StatusBar(16);

void CUpDownClient::DrawStatusBar(wxMemoryDC * dc, wxRect rect, bool onlygreyrect, bool bFlat)
{
    DWORD crBoth;
    DWORD crNeither;

    // Barry - was only showing one part from client, even when reserved bits from 2 parts
    wxString gettingParts;
    ShowDownloadingParts(gettingParts);
    if (!onlygreyrect && reqfile && m_abyPartStatus)
    {
        for (uint32 i = 0 ; i != m_nPartCount ; i++)
        {

                uEnd = reqfile -> GetFileSize();
                else
                uEnd = PARTSIZE * (i + 1);
                if (reqfile -> IsComplete(PARTSIZE * i, PARTSIZE * (i + 1) - 1))
                s_StatusBar.FillRange(PARTSIZE * i, uEnd, crBoth);
                else if(m_nDownloadState == DS_DOWNLOADING && m_nLastBlockOffset < uEnd &&
                m_nLastBlockOffset >= PARTSIZE * i)
                s_StatusBar.FillRange(PARTSIZE * i, uEnd, crPending);
                else if(gettingParts.GetChar(i) == 'Y')
                s_StatusBar.FillRange(PARTSIZE * i, uEnd, crNextPending);
                else
                s_StatusBar.FillRange(PARTSIZE * i, uEnd, crClientOnly);
            }
        }
    }
    s_StatusBar.Draw(dc, rect.x, rect.y, bFlat);
}

bool CUpDownClient::Compare(CUpDownClient * tocomp)
{
    if (HasValidHash() && tocomp -> HasValidHash())
    return !memcmp(this -> GetUserHash(), tocomp -> GetUserHash(), 16);
    if (HasLowID())
    return((this -> GetUserID() == tocomp -> GetUserID()) && (GetServerIP() == tocomp -> GetServerIP()));
    else
    return(this -> GetUserID() == tocomp -> GetUserID() || (this -> GetIP() && this -> GetIP() == tocomp -> GetIP()));
}

void CUpDownClient::AskForDownload()
{
    int rank = GetRemoteQueueRank();
    if (GetDownloadState() == DS_CONNECTING)

    {
        m_cFailed = 0;
    }
    bool hotrank = (rank && rank < 5);
    if (theApp.listensocket -> TooManySockets(hotrank) && ! (socket && socket -> IsConnected()))
    {
        if (GetDownloadState() != DS_TOOMANYCONNS)
        {

            socket -> hotrank = hotrank;
        }
        m_bUDPPending = false;
        m_dwLastAskedTime =::GetTickCount();
        if (m_cFailed < 3)
        {
            SetDownloadState(DS_CONNECTING);

    }
}

bool CUpDownClient::IsSourceRequestAllowed()
{
    DWORD dwTickCount =::GetTickCount() + CONNECTION_LATENCY;
    int nTimePassedClient = dwTickCount - GetLastSrcAnswerTime();
    int nTimePassedFile = dwTickCount - reqfile -> GetLastAnsweredTime();
    bool bNeverAskedBefore = GetLastSrcReqTime() == 0;
    return(
    //if client has the correct extended protocol
    ExtProtocolAvailable() && m_bySourceExchangeVer >= 1 &&
    //AND if we need more sources
    theApp.glob_prefs -> GetMaxSourcePerFileSoft() > reqfile -> GetSourceCount() &&
    //AND if...

    //source is not complete and file is rare, allow once every 10 minutes
    (!m_bCompleteSource &&
    (reqfile -> GetSourceCount() - reqfile -> GetValidSourcesCount() <= RARE_FILE / 4 ||
    reqfile -> GetSourceCount() <= RARE_FILE * 2
    ) &&
    (bNeverAskedBefore || nTimePassedClient > SOURCECLIENTREASK)
    ) ||
    // otherwise, allow every 90 minutes, but only if we haven't
    //   asked someone else in last 10 minutes
    ((bNeverAskedBefore || nTimePassedClient > SOURCECLIENTREASK * reqfile -> GetCommonFilePenalty()) &&
    (nTimePassedFile > SOURCECLIENTREASK)
    )
    )
    );
}

void CUpDownClient::SendFileRequest()
{
    if (reqfile)
    {
        AddAskedCountDown();
        CSafeMemFile * dataFileReq;
        if (newprefs02_opt[1])
        {
            dataFileReq = new CSafeMemFile(32);

        {
            CSafeMemFile dataSetReqFileID(16);
            dataSetReqFileID.Write(reqfile -> GetFileHash(), 16);
            NewSocket_SendPacketOPdata(2, OP_SETREQFILEID, & dataSetReqFileID, (wxUint32) this, 0);
        }
        if (IsEmuleClient())
        {

            if (IsSourceRequestAllowed())
            {
                reqfile -> SetLastAnsweredTimeTimeout();
                Packet * packet = new Packet(OP_REQUESTSOURCES, 16, OP_EMULEPROT);
                md4cpy(packet -> pBuffer, reqfile -> GetFileHash());
                NewSocket_SendPacketOP(2, OP_REQUESTSOURCES, packet, (wxUint32) this, 0);
                SetLastAskedForSources();

    }
}

void CUpDownClient::ProcessFileInfo(char * packet, uint32 size)
{
    CSafeMemFile * data = new CSafeMemFile((BYTE *) packet, size);
    uchar cfilehash[16];
    data -> Read(cfilehash, 16);
    uint16 namelength;
    data -> Read( & namelength, 2);
    if (m_pszClientFilename)
    {
    delete[] m_pszClientFilename;
	}
    m_pszClientFilename = new char[namelength + 1];

    delete data;
}

void CUpDownClient::ProcessFileStatus(char * packet, uint32 size)
{
    CSafeMemFile * data = new CSafeMemFile((BYTE *) packet, size);
    uchar cfilehash[16];
    data -> Read(cfilehash, 16);
    if ((reqfile) && (!memcmp(cfilehash, reqfile -> GetFileHash(), 16)))
    {
        data -> Read( & m_nPartCount, 2);
        if (m_abyPartStatus)
        {
            delete[] m_abyPartStatus;

                while (done != m_nPartCount)
                {
                    uint8 toread;
                    data -> Read( & toread, 1);
                    for (sint32 i = 0 ; i != 8 ; i++)
                    {
                        m_abyPartStatus[done] = ((toread >> i) & 1) ? 1: 0;
                        if (m_abyPartStatus[done] && !reqfile -> IsComplete(done * PARTSIZE, ((done + 1) * PARTSIZE) - 1))
                        bPartsNeeded = true;
                        done++;
                        if (done == m_nPartCount)

        if (!bPartsNeeded)
        {
            SetDownloadState(DS_NONEEDEDPARTS);
	    if(reqfile->GetDownPriority()==PR_LOW) {
	    	SwapToAnotherFile();
	    }
        }
        else if(reqfile -> hashsetneeded)
        {
            Packet * packet = new Packet(OP_HASHSETREQUEST, 16);
            memcpy(packet -> pBuffer, reqfile -> GetFileHash(), 16);
            NewSocket_SendPacketOP(2, OP_HASHSETREQUEST, packet, (wxUint32) this, 0);
            SetDownloadState(DS_REQHASHSET);

    delete data;
}

bool CUpDownClient::AddRequestForAnotherFile(CPartFile * file)
{
    for (POSITION pos = m_OtherNoNeeded_list.GetHeadPosition() ; pos != 0 ; m_OtherNoNeeded_list.GetNext(pos))
    {

    return true;
}

void CUpDownClient::SetDownloadState(uint8 byNewState)
{
    if (m_nDownloadState != byNewState)
    {

            m_nDownloadState = byNewState;
            for (POSITION pos = m_DownloadBlocks_list.GetHeadPosition() ; pos != 0 ; m_DownloadBlocks_list.GetNext(pos))
            {
                Requested_Block_Struct * cur_block = m_DownloadBlocks_list.GetAt(pos);
                reqfile -> RemoveBlockFromList(cur_block -> StartOffset, cur_block -> EndOffset);
                delete m_DownloadBlocks_list.GetAt(pos);
            }
            m_DownloadBlocks_list.RemoveAll();
            for (POSITION pos = m_PendingBlocks_list.GetHeadPosition() ; pos != 0 ; m_PendingBlocks_list.GetNext(pos))
            {
                Pending_Block_Struct * pending = m_PendingBlocks_list.GetAt(pos);
                if (reqfile)
                reqfile -> RemoveBlockFromList(pending -> block -> StartOffset, pending -> block -> EndOffset);
                delete pending -> block;

                delete[] m_abyPartStatus;
                m_abyPartStatus = 0;
            }
            if (socket && byNewState != DS_ERROR)
            socket -> DisableDownloadLimit();
        }
        m_nDownloadState = byNewState;

    }
}

void CUpDownClient::ProcessHashSet(unsigned char * packet, uint32 size)
{
    if (reqfile && (!memcmp(packet, reqfile -> GetFileHash(), 16)))
    {
        if (m_bHashsetRequested)
        {
            m_bHashsetRequested = false;
            CSafeMemFile * data = new CSafeMemFile((BYTE *) packet, size);
            if (reqfile -> LoadHashsetFromFile(data, true))
            {
                SetDownloadState(DS_ONQUEUE);

    }
}

void CUpDownClient::SendBlockRequests()
{
    m_dwLastBlockReceived =::GetTickCount();
    if (reqfile)
    {
        if (m_DownloadBlocks_list.IsEmpty())
        {
            // Barry - instead of getting 3, just get how many is needed
            uint16 count = 3 - m_PendingBlocks_list.GetCount();
            Requested_Block_Struct ** toadd = new Requested_Block_Struct *[count];
            if (reqfile -> GetNextRequestedBlock(this, toadd, & count))
            {
                for (int i = 0 ; i != count ; i++)
                m_DownloadBlocks_list.AddTail(toadd[i]);

        // Barry - Why are unfinished blocks requested again, not just new ones?
        while (m_PendingBlocks_list.GetCount() < 3 && !m_DownloadBlocks_list.IsEmpty())
        {
            Pending_Block_Struct * pblock = new Pending_Block_Struct;
            pblock -> block = m_DownloadBlocks_list.RemoveHead();
            pblock -> zStream = NULL;
            pblock -> totalUnzipped = 0;

        {
            NewSocket_SendPacketOPdata(2, OP_CANCELTRANSFER, NULL, (wxUint32) this, 0);
            SetDownloadState(DS_NONEEDEDPARTS);
	    if(reqfile->GetDownPriority()==PR_LOW) {
	      SwapToAnotherFile();
	    }
        }
        else
        {
            CMemFile * data = new CMemFile(40);
            data -> Write(reqfile -> GetFileHash(), 16);
            POSITION pos = m_PendingBlocks_list.GetHeadPosition();
            uint32 null = 0;
            Requested_Block_Struct * block;
            for (uint32 i = 0 ; i != 3 ; i++)
            {
                if (pos)
                {
                    block = m_PendingBlocks_list.GetAt(pos) -> block;
                    m_PendingBlocks_list.GetNext(pos);
                    data -> Write( & block -> StartOffset, 4);
                }
                else
                {
                    data -> Write( & null, 4);
                }
            }
            pos = m_PendingBlocks_list.GetHeadPosition();

                    block = m_PendingBlocks_list.GetAt(pos) -> block;
                    m_PendingBlocks_list.GetNext(pos);
                    uint32 endpos = block -> EndOffset + 1;
                    data -> Write( & endpos, 4);
                }
                else
                {
                    data -> Write( & null, 4);
                }
            }
            NewSocket_SendPacketOPdata(2, OP_REQUESTPARTS, data, (wxUint32) this, 0);

    }
}

void CUpDownClient::ProcessBlockPacket(char * packet, uint32 size, bool packed)
{
    // Ignore if no data required
    if (GetDownloadState() == DS_DOWNLOADING || GetDownloadState() == DS_NONEEDEDPARTS)
    {
    const int HEADER_SIZE = 24;
        m_dwLastBlockReceived =::GetTickCount();
        CSafeMemFile * data = new CSafeMemFile((BYTE *) packet, size);
    // Read data from packet
    CSafeMemFile *data = new CSafeMemFile((BYTE *) packet, size);
    uchar fileID[16];
    data -> Read(fileID, 16);
        if (reqfile && (!memcmp(packet, reqfile -> GetFileHash(), 16)))
    if (reqfile && (! memcmp(packet, reqfile -> GetFileHash(), 16)))
    {
        // Find the start & end positions, and size of this chunk of data
        uint32 nStartPos;
        uint32 nEndPos;
        uint32 nBlockSize = 0;
            data -> Read( & nStartPos, 4);
        if (packed)
        {
                data -> Read( & nBlockSize, 4);
            nEndPos = nStartPos + (size - HEADER_SIZE);
            usedcompressiondown = true;
        }
        else
        {
                data -> Read( & nEndPos, 4);
        }
        // Check that packet size matches the declared data size + header size (24)
        if (size == ((nEndPos - nStartPos) + HEADER_SIZE))
        {
            // Move end back one, should be inclusive
            theApp.UpdateReceivedBytes(size - HEADER_SIZE);
            m_nDownDataRateMS += size - HEADER_SIZE;
            credits -> AddDownloaded(size - HEADER_SIZE, GetIP());
            nEndPos--;
                Pending_Block_Struct * cur_block;
                for (POSITION pos = m_PendingBlocks_list.GetHeadPosition() ;
                pos != NULL ; m_PendingBlocks_list.GetNext(pos))
            {
                cur_block = m_PendingBlocks_list.GetAt(pos);
                    if ((cur_block -> block -> StartOffset <= nStartPos) &&
                    (cur_block -> block -> EndOffset >= nStartPos))
                {
                    // Found reserved block
                    if (cur_block -> bZStreamError)
                    {
                        theApp.xmuledlg -> AddDebugLogLine(false, _T("Ignoring %u bytes of block %u-%u because of errornous zstream state for file \"%s\""), size - HEADER_SIZE, nStartPos, nEndPos, reqfile -> GetFileName());
                        reqfile -> RemoveBlockFromList(cur_block -> block -> StartOffset, cur_block -> block -> EndOffset);
                        return;
                    }
                    // Remember this start pos, used to draw part downloading in list
                    m_nLastBlockOffset = nStartPos;
                    // Occasionally packets are duplicated, no point writing it twice
                    // This will be 0 in these cases, or the length written otherwise
                    uint32 lenWritten = 0;
                    // Handle differently depending on whether packed or not
                    if (!packed)
                    {
                        // Write to disk (will be buffered in part file class)
                        lenWritten = reqfile -> WriteToBuffer(size - HEADER_SIZE,
                        (BYTE *)(packet + HEADER_SIZE),
                        nStartPos,
                        nEndPos,
                        cur_block -> block);
                        // Packed:
                    }
                    else
                    {
                            uint32 lenUnzipped = (size * 2);
                        uint32 lenUnzipped = (size *2);
                        // Don't get too big
                        if (lenUnzipped > (GAPBLOCKSIZE + 300))
                            {
                        lenUnzipped = (GAPBLOCKSIZE + 300);
                            }
                            BYTE * unzipped = new BYTE[lenUnzipped];
                            int result = unzip(cur_block, (BYTE *)(packet + HEADER_SIZE), (size - HEADER_SIZE), & unzipped, & lenUnzipped);
                        if (result == Z_OK)
                        {
                            // Write any unzipped data to disk
                            if (lenUnzipped > 0)
                            {
                                // Use the current start and end positions for the uncompressed data
                                nStartPos = cur_block -> block -> StartOffset + cur_block -> totalUnzipped - lenUnzipped;
                                nEndPos = cur_block -> block -> StartOffset + cur_block -> totalUnzipped - 1;
                                if (nStartPos > cur_block -> block -> EndOffset || nEndPos > cur_block -> block -> EndOffset)

                                }
                                else
                                {
                                    // Write uncompressed data to file
                                    lenWritten = reqfile -> WriteToBuffer(size - HEADER_SIZE,
                                    unzipped,
                                    nStartPos,

                        else
                        {
                            CString strZipError;
                                if (cur_block -> zStream && cur_block -> zStream -> msg)
                            strZipError.Format(_T(" - %s"), cur_block -> zStream -> msg);
                                theApp.xmuledlg -> AddDebugLogLine(false, GetResString(IDS_ERR_CORRUPTCOMPRPKG)
                                + strZipError, reqfile -> GetFileName(), result);
                                reqfile -> RemoveBlockFromList(cur_block -> block -> StartOffset,
                                cur_block -> block -> EndOffset);
                            if (cur_block -> zStream)
                            {
                                inflateEnd(cur_block -> zStream);
                                delete cur_block -> zStream;
                                cur_block -> zStream = NULL;
                            }
                            // Although we can't further use the current zstream, there is no need to disconnect the sending
                            // client because the next zstream (a series of 10K-blocks which build a 180K-block) could be
                            // valid again. Just ignore all further blocks for the current zstream.
                            cur_block -> bZStreamError = true;
                        }
                        delete [] unzipped;
                    }
                    // These checks only need to be done if any data was written
                    if (lenWritten > 0)
                    {
                        m_nTransferedDown += lenWritten;
                        // If finished reserved block
                        if (nEndPos == cur_block -> block -> EndOffset)
                        {
                                reqfile -> RemoveBlockFromList(cur_block -> block -> StartOffset,
                                cur_block -> block -> EndOffset);
                            delete cur_block -> block;
                            // Not always allocated
                            if (cur_block -> zStream)
                            {
                                inflateEnd(cur_block -> zStream);

                            }
                            delete cur_block;
                            m_PendingBlocks_list.RemoveAt(pos);
                            // Request next block
                            SendBlockRequests();
                        }
                    }
                    // Stop looping and exit method
                    return;
                }
            }
        }
    }
    delete data;
    }
}

int CUpDownClient::unzip(Pending_Block_Struct * block, BYTE * zipped, uint32 lenZipped, BYTE ** unzipped, uint32 * lenUnzipped, bool recursive)
{
    int err = Z_DATA_ERROR;
    try
    {
        // Save some typing
        z_stream * zS = block -> zStream;
        // Is this the first time this block has been unzipped
        if (zS == NULL)
        {

            zS -> zfree = (free_func) 0;
            zS -> opaque = (voidpf) 0;
            // Set output data streams, do this here to avoid overwriting on recursive calls
            zS -> next_out = ( * unzipped);
            zS -> avail_out = ( * lenUnzipped);
            // Initialise the z_stream
            err = inflateInit(zS);
            if (err != Z_OK)

        // Only set the output if not being called recursively
        if (!recursive)
        {
            zS -> next_out = ( * unzipped);
            zS -> avail_out = ( * lenUnzipped);
        }
        // Try to unzip the data
        err = inflate(zS, Z_SYNC_FLUSH);

            if (err != Z_OK)
            return err;
            // Got a good result, set the size to the amount unzipped in this call (including all recursive calls)
            ( * lenUnzipped) = (zS -> total_out - block -> totalUnzipped);
            block -> totalUnzipped = zS -> total_out;
        }
        else if((err == Z_OK) && (zS -> avail_out == 0))
        {
            // Output array was not big enough, call recursively until there is enough space
            // What size should we try next
            uint32 newLength = ( * lenUnzipped) *= 2;
            if (newLength == 0)
            newLength = lenZipped * 2;
            // Copy any data that was successfully unzipped to new array
            BYTE * temp = new BYTE[newLength];
            memcpy(temp, ( * unzipped), (zS -> total_out - block -> totalUnzipped));
            delete [] ( * unzipped);
            ( * unzipped) = temp;
            ( * lenUnzipped) = newLength;
            // Position stream output to correct place in new array
            zS -> next_out = ( * unzipped) + (zS -> total_out - block -> totalUnzipped);
            zS -> avail_out = ( * lenUnzipped) - (zS -> total_out - block -> totalUnzipped);
            // Try again
            err = unzip(block, zS -> next_in, zS -> avail_in, unzipped, lenUnzipped, true);
        }

        {
            // All available input has been processed, everything ok.
            // Set the size to the amount unzipped in this call (including all recursive calls)
            ( * lenUnzipped) = (zS -> total_out - block -> totalUnzipped);
            block -> totalUnzipped = zS -> total_out;
        }
        else

            //		DebugBreak(); I removed this so that we could let the client run for more the five minutes.. Barry needs to see if there is or isn't a preoblem here..
        }
        if (err != Z_OK)
        ( * lenUnzipped) = 0;
    }
    catch(...)
    {

    return err;
}

uint32 CUpDownClient::CalculateDownloadRate()
{
    m_AvarageDDR_list.AddTail(m_nDownDataRateMS);
    m_nSumForAvgDownDataRate += m_nDownDataRateMS;

    m_nSumForAvgDownDataRate -= m_AvarageDDR_list.RemoveHead();
    m_nDownDataRateMS = 0;
    if (m_AvarageDDR_list.GetCount() > 10)
    m_nDownDatarate = 10 * m_nSumForAvgDownDataRate / m_AvarageDDR_list.GetCount();
    else
    m_nDownDatarate = 0;
    m_cShowDR++;
    if (m_cShowDR == 30)
    {
        m_cShowDR = 0;
        //theApp.xmuledlg->transferwnd.downloadlistctrl.UpdateItem(this);
        UpdateDisplayedInfo();
    }
    if ((::GetTickCount() - m_dwLastBlockReceived) > DOWNLOADTIMEOUT)
    {
        NewSocket_SendPacketOPdata(2, OP_CANCELTRANSFER, NULL, (wxUint32) this, 1);
        SetDownloadState(DS_ONQUEUE);

    return m_nDownDatarate;
}

uint16 CUpDownClient::GetAvailablePartCount()
{
    uint16 result = 0;
    for (int i = 0 ; i != m_nPartCount ; i++)

    return result;
}

void CUpDownClient::SetRemoteQueueRank(uint16 nr)
{
    m_nRemoteQueueRank = nr;
    theApp.xmuledlg -> transferwnd -> downloadlistctrl -> UpdateItem(this);
}

void CUpDownClient::UDPReaskACK(uint16 nNewQR)
{
    m_bUDPPending = false;
    SetRemoteQueueRank(nNewQR);
    m_dwLastAskedTime =::GetTickCount();
}

void CUpDownClient::UDPReaskFNF()
{
    m_bUDPPending = false;
    theApp.downloadqueue -> RemoveSource(this);

    }
}

void CUpDownClient::UDPReaskForDownload()
{
    if (reqfile && (!m_bUDPPending))
    {
        //the line "m_bUDPPending = true;" use to be here
        if (m_nUDPPort != 0 && theApp.glob_prefs -> GetUDPPort() != 0 &&
        !theApp.serverconnect -> IsLowID() && !HasLowID() && ! (socket && socket -> IsConnected()))
        {
            //don't use udp to ask for sources
            if (IsSourceRequestAllowed())

                {
                    packetsize = 16;
                }
                Packet * response = new Packet(OP_REASKFILEPING, packetsize, OP_EMULEPROT);
                md4cpy(response -> pBuffer, reqfile -> GetFileHash());
                // #zegzav:completesrc (modify):
                if (GetUDPVersion() >= 3)
                {
                    uint16 completecount = reqfile -> m_nCompleteSourcesCount;
                    memcpy(response -> pBuffer + 16, & completecount, 2);
                }
                NewSocket_SendPacketOP(1, OP_REASKFILEPING, response, GetIP(), GetUDPPort());
            }

}

// Barry - Sets string to show parts downloading, eg NNNYNNNNYYNYN
void CUpDownClient::ShowDownloadingParts(wxString & partsYN)
{
    Requested_Block_Struct * cur_block;
    unsigned int x;
    partsYN.Alloc(m_nPartCount + 1);
    for (x = 0 ; x <= m_nPartCount ; x++) partsYN.SetChar(x, 'N');

        {
            partsYN.SetChar(x, 'Y');
        }
        else
        {
            //printf("CUpDownClient::ShowDownloadingParts x(%ld) > partsYN.Len()(%ld) pc=%ld\n",
            //x, partsYN.Len(), m_nPartCount);
        }
    }
}

void CUpDownClient::UpdateDisplayedInfo(bool force)
{
    DWORD curTick =::GetTickCount();
    if (force || curTick - m_lastRefreshedDLDisplay > MINWAIT_BEFORE_DLDISPLAY_WINDOWUPDATE + (uint32)(rand() / (RAND_MAX/ 1000)))
    {
        theApp.xmuledlg -> transferwnd -> downloadlistctrl -> UpdateItem(this);
        m_lastRefreshedDLDisplay = curTick;

 /* Razor 1a - Modif by MikaelB
    SwapToThisFile function */

void CUpDownClient::SwapToThisFile(CPartFile * file)
{
    // Get the position of the file in other requests' list
    POSITION position = this -> m_OtherRequests_list.Find(file);

        // Add file at the head of other requests' list
        this -> m_OtherRequests_list.AddHead(file);
        // Some files
        CPartFile * SwapFile, * TempFile, * RequestedFile;
        TempFile = this -> m_OtherRequests_list.GetHead();
        RequestedFile = this -> reqfile;
        // If the file at the head of other requests' list isn't the requested file

            // if position isn't null...
            if (position)
            {
                // Remove source at position from the sources list of requested file
                RequestedFile -> srclists[this -> sourcesslot].RemoveAt(position);
                // Remove source of this client from requested file in the download list
                theApp.xmuledlg -> transferwnd -> downloadlistctrl -> RemoveSource(this, RequestedFile);
                // Add this source in the A4AF sources list of the requested file
                RequestedFile -> A4AFSourcesList.AddTail(this);
                // Add the requested file in the other requests' list
                this -> m_OtherRequests_list.AddTail(RequestedFile);
                // Add source of requested file from this client in the download list
                theApp.xmuledlg -> transferwnd -> downloadlistctrl -> AddSource(RequestedFile, this, true);
                // Update requested file's sources infos
                RequestedFile -> NewSrcPartsInfo();
                // Update requested file's parts counts
                RequestedFile -> UpdateAvailablePartsCount();
                // Set download state of this client to no
                this -> SetDownloadState(DS_NONE);
                // Set requested file to 0
                RequestedFile = 0;
                // Set remote queue rank to 0
                this -> m_nRemoteQueueRank = 0;
                // If  abyPartStatus isn't null
                if (this -> m_abyPartStatus)
                {
                    // Delete abyPartStatus
                    delete[] this -> m_abyPartStatus;
                    // Set it to null
                    this -> m_abyPartStatus = 0;
                }
                // Set part count to
                this -> m_nPartCount = 0;
                // Set last asked time to 0
                this -> m_dwLastAskedTime = 0;
                // set irate to 0
                this -> m_iRate = 0;
                // Set comment to ""
                this -> m_strComment = "";
                // If pszClientFilename isn't null
                if (this -> m_pszClientFilename)
                {
                    // Delete pszClientFilename
                    delete this -> m_pszClientFilename;
                    // Set it to 0
                    this -> m_pszClientFilename = 0;
                }
                // Set requested file to swapped file
                this -> reqfile = SwapFile;
                // Add this source in the sources list of swapped file
                SwapFile -> srclists[this -> sourcesslot].AddTail(this);
                // Add source of swapped file from this client to download list
                theApp.xmuledlg -> transferwnd -> downloadlistctrl -> AddSource(SwapFile, this, false);
            }
        }
        // Else if swapped file isn't null...
        else if(SwapFile)
        {
            // Add it to other requests' list
            this -> m_OtherRequests_list.AddHead(SwapFile);
            // Add this source to A4AF sources list of swapped file
            this -> m_OtherRequests_list.GetHead() -> A4AFSourcesList.AddHead(this);
        }
        // Else...
        else
        {
        this -> m_OtherRequests_list.GetHead() -> A4AFSourcesList.AddHead(this);
    }
    }
    else
    {
    file -> A4AFSourcesList.AddHead(this);
    }
}

 /* Razor 1a - Modif by MikaelB
    Made some changes in SwapToAnoterFile function */

bool CUpDownClient::SwapToAnotherFile()
{
    if (this -> GetDownloadState() == DS_DOWNLOADING) {
    return false;
    }
    if (!this -> m_OtherRequests_list.IsEmpty())
    {
        CPartFile * SwapTo = NULL;
        POSITION pos, pos1, pos2;
        for (pos1 = this -> m_OtherRequests_list.GetHeadPosition() ; (pos2 = pos1) != NULL ;)
        {
            this -> m_OtherRequests_list.GetNext(pos1);
            CPartFile * cur_file = this -> m_OtherRequests_list.GetAt(pos2);
            if (cur_file != this -> reqfile
            && theApp.downloadqueue -> IsPartFile(cur_file)
            && !cur_file -> IsStopped()
            && (cur_file -> GetStatus(false) == PS_READY || cur_file -> GetStatus(false) == PS_EMPTY))
            {


    /* End modif */

void CUpDownClient::SetDownloadFile(CPartFile * part)
{
    delete[] m_abyPartStatus;
    m_abyPartStatus = NULL;

Lines 109-114 Link Here

(-)xmule/src/DownloadListCtrl.cpp (-4 / +34 lines)
109	EVT_MENU(MP_CANCEL,CDownloadListCtrl::OnMCancel)	109	EVT_MENU(MP_CANCEL,CDownloadListCtrl::OnMCancel)
110	*/	110	*/
111		111
		112	int fireup=0;
		113
112	void preloadImages(wxImageList *imgs)	114	void preloadImages(wxImageList *imgs)
113	{	115	{
114	imgs -> Add(wxBitmap(client0_ICO));	116	imgs -> Add(wxBitmap(client0_ICO));
Lines 193-203 Link Here
193	if ((isShift \|\| isCtrl \|\| isAlt) && (cl -> GetDownloadFile() == toCollapse))	195	if ((isShift \|\| isCtrl \|\| isAlt) && (cl -> GetDownloadFile() == toCollapse))
194	{	196	{
195	uint8 ds = cl -> GetDownloadState();	197	uint8 ds = cl -> GetDownloadState();
		198	if(fireup==30002) {
		199	if(ds!=DS_NONEEDEDPARTS) {
		200	printf("fireup: %u\n",(uint32)cl);
		201	continue;
		202	}
		203	} else {
196	if ((isShift &&ds == DS_DOWNLOADING) \|\| (isCtrl &&cl -> GetRemoteQueueRank() > 0) \|\| (isAlt &&ds != DS_NONEEDEDPARTS))	204	if ((isShift &&ds == DS_DOWNLOADING) \|\| (isCtrl &&cl -> GetRemoteQueueRank() > 0) \|\| (isAlt &&ds != DS_NONEEDEDPARTS))
197	{	205	{
198	continue;	206	continue;
199	}	207	}
200	}	208	}
		209	}
201	item -> dwUpdated = 0;	210	item -> dwUpdated = 0;
202	//item->status.DeleteObject();	211	//item->status.DeleteObject();
203	if (item -> status)	212	if (item -> status)
Lines 383-388 Link Here
383	menu -> Append(MP_CANCEL, GetResString(IDS_MAIN_BTN_CANCEL));	392	menu -> Append(MP_CANCEL, GetResString(IDS_MAIN_BTN_CANCEL));
384	menu -> Append(MP_STOP, GetResString(IDS_DL_STOP));	393	menu -> Append(MP_STOP, GetResString(IDS_DL_STOP));
385	menu -> Append(MP_PAUSE, GetResString(IDS_DL_PAUSE));	394	menu -> Append(MP_PAUSE, GetResString(IDS_DL_PAUSE));
		395	menu -> Append(30002, "Sourcecrunching");
386	menu -> Append(MP_RESUME, GetResString(IDS_DL_RESUME));	396	menu -> Append(MP_RESUME, GetResString(IDS_DL_RESUME));
387	menu -> AppendSeparator();	397	menu -> AppendSeparator();
388	/* Razor 1a - Modif by MikaelB	398	/* Razor 1a - Modif by MikaelB
Lines 446-452 Link Here
446	menu -> Enable(MP_RESUME, ((file -> GetStatus() == PS_PAUSED) ? MF_ENABLED: MF_GRAYED));	456	menu -> Enable(MP_RESUME, ((file -> GetStatus() == PS_PAUSED) ? MF_ENABLED: MF_GRAYED));
447	//<<--9/21/02:	457	//<<--9/21/02:
448	menu -> Enable(MP_OPEN, ((file -> GetStatus() == PS_COMPLETE) ? MF_ENABLED: MF_GRAYED));	458	menu -> Enable(MP_OPEN, ((file -> GetStatus() == PS_COMPLETE) ? MF_ENABLED: MF_GRAYED));
449	menu -> SetLabel(MP_PREVIEW, wxString:: Format(_("Preview [%s]"), file -> GetPartMetFileName()));	459	menu -> SetLabel(MP_PREVIEW, wxString:: Format(_("Preview [%s]"), file -> GetPartMetFileName().GetData()));
450	menu -> Enable(MP_PREVIEW, ((file -> PreviewAvailable()) ? MF_ENABLED: MF_GRAYED));	460	menu -> Enable(MP_PREVIEW, ((file -> PreviewAvailable()) ? MF_ENABLED: MF_GRAYED));
451	/* Razor 1a - Modif by MikaelB	461	/* Razor 1a - Modif by MikaelB
452	Set menu items' state for :	462	Set menu items' state for :
Lines 2052-2057 Link Here
2052	file -> SavePartFile();	2062	file -> SavePartFile();
2053	break;	2063	break;
2054	case MP_STOP:	2064	case MP_STOP:
		2065	fireup=0;
2055	if (selectedCount > 1)	2066	if (selectedCount > 1)
2056	{	2067	{
2057	Freeze();	2068	Freeze();
Lines 2059-2072 Link Here
2059	{	2070	{
2060	CPartFile *selected = selectedList.GetHead();	2071	CPartFile *selected = selectedList.GetHead();
2061	HideSources(selected);	2072	HideSources(selected);
2062	selected -> StopFile();	2073	selected -> StopFile(0);
2063	selectedList.RemoveHead();	2074	selectedList.RemoveHead();
2064	}	2075	}
2065	Thaw();	2076	Thaw();
		2077	} else {
		2078	HideSources(file);
		2079	file -> StopFile(0);
		2080	}
2066	break;	2081	break;
		2082	case 30002:
		2083	fireup=30002;
		2084	if (selectedCount > 1)
		2085	{
		2086	// Freeze();
		2087	while (!selectedList.IsEmpty())
		2088	{
		2089	CPartFile *selected = selectedList.GetHead();
		2090	//HideSources(selected);
		2091	selected -> RemoveAllSources(fireup,true);
		2092	selectedList.RemoveHead();
2067	}	2093	}
2068	HideSources(file);	2094	// Thaw();
2069	file -> StopFile();	2095	} else {
		2096	//HideSources(file);
		2097	file -> RemoveAllSources(fireup,true);
		2098	}
		2099	fireup=0;
2070	break;	2100	break;
2071	case MP_CLEARCOMPLETED:	2101	case MP_CLEARCOMPLETED:
2072	Freeze();	2102	Freeze();




            wxFileName myFileName(fileName);
            printf("Loading %s... ", myFileName.GetFullName() .GetData());
            CPartFile *toadd = new CPartFile();
            if (toadd -> LoadPartFile(count0,app_prefs -> GetTempDir(), (char *) myFileName.GetFullName() .GetData()))
            {
		switch(count0) {
		case 0:
			toadd->SetIsDynamic(false);break;
		case 1:
			toadd->SetIsDynamic(true);break;
		}
                count++;
                printf("Done.\n");
                filelist.AddTail(toadd);

                cur_file -> PauseFile();
                break;
            case MP_STOP:
                cur_file -> StopFile(0);
                break;
            case MP_RESUME:
                if (cur_file -> GetStatus() == PS_PAUSED)

Lines 110-115 Link Here

(-)xmule/src/FlowChart.cpp (-7 / +62 lines)
110	wxMenu *pop_oldprefs09;	110	wxMenu *pop_oldprefs09;
111		111
112	int newprefs01_opt[101];	112	int newprefs01_opt[101];
		113	wxString newprefs01_alpha[101];
113		114
114	wxString newprefs01info[256];	115	wxString newprefs01info[256];
115		116
Lines 172-178 Link Here
172		173
173	void Load_NewPrefs01()	174	void Load_NewPrefs01()
174	{	175	{
175	for (int i = 0 ; i < 7 ; i++)	176	int i=0;
		177	for (i = 1 ; i <= 100 ; i++)
		178	{
		179	newprefs01_opt[i] = 0;
		180	newprefs01_alpha[i] = "";
		181	}
		182	for (i = 0 ; i < 7 ; i++)
176	{	183	{
177	switch(i) {	184	switch(i) {
178	case 3:	185	case 3:
Lines 204-210 Link Here
204	(void) fread( &byte, 1, 1, newprefs01_fd);	211	(void) fread( &byte, 1, 1, newprefs01_fd);
205	line += (wxChar) byte[0];	212	line += (wxChar) byte[0];
206	}	213	}
207	for (int i = 0 ; i < 7 ; i++)	214	for (i = 0 ; i < 7 ; i++)
208	{	215	{
209	if (i *4 <= line.Len())	216	if (i *4 <= line.Len())
210	{	217	{
Lines 212-221 Link Here
212	}	219	}
213	}	220	}
214	(void) fclose(newprefs01_fd);	221	(void) fclose(newprefs01_fd);
		222	newprefs01_filename = wxString:: Format("%s/.xMule/", getenv("HOME")) + wxT("newprefs01.alp");
		223	newprefs01_fd = fopen(newprefs01_filename, "r");
		224	if (newprefs01_fd == NULL)
		225	{
		226	newprefs01_fd = fopen(newprefs01_filename, "w");
		227	(void) fclose(newprefs01_fd);
		228	newprefs01_fd = fopen(newprefs01_filename, "r");
		229	}
		230	line = "";
		231	long v;
		232	while (!feof(newprefs01_fd))
		233	{
		234	(void) fread( &byte, 1, 1, newprefs01_fd);
		235	switch(byte[0]) {
		236	case 10:
		237	line.Mid(1,3).ToLong(&v);
		238	newprefs01_alpha[v]=line.Mid(4);
		239	case 13:break;
		240	case 0:break;
		241	default:
		242	line += (wxChar) byte[0];
		243	break;
		244	}
		245	}
		246	(void) fclose(newprefs01_fd);
215	}	247	}
216		248
217	void Save_NewPrefs01()	249	void Save_NewPrefs01()
218	{	250	{
		251	int i=0;
219	FILE *newprefs01_fd;	252	FILE *newprefs01_fd;
220	wxString line;	253	wxString line;
221	wxString newprefs01_filename = wxString:: Format("%s/.xMule/", getenv("HOME")) + wxT("newprefs01.dat");	254	wxString newprefs01_filename = wxString:: Format("%s/.xMule/", getenv("HOME")) + wxT("newprefs01.dat");
Lines 223-234 Link Here
223	if (newprefs01_fd != NULL)	256	if (newprefs01_fd != NULL)
224	{	257	{
225	line = "";	258	line = "";
226	for (int i = 0 ; i < 7 ; i++)	259	for (i = 0 ; i < 7 ; i++)
227	{	260	{
228	line += " ";	261	line += " ";
229	memcpy((void )(((const char ) line) + i *4), &newprefs01_opt[i], 4);	262	memcpy((void )(((const char ) line) + i *4), &newprefs01_opt[i], 4);
230	}	263	}
231	(void) fwrite(((const char *) line), 1, line.Len(), newprefs01_fd);	264	(void) fwrite((const char *) line, 1, line.Len(), newprefs01_fd);
		265	(void) fclose(newprefs01_fd);
		266	}
		267	newprefs01_filename = wxString:: Format("%s/.xMule/", getenv("HOME")) + wxT("newprefs01.alp");
		268	newprefs01_fd = fopen(newprefs01_filename, "w");
		269	if (newprefs01_fd != NULL)
		270	{
		271	for (i = 0 ; i < 100 ; i++)
		272	{
		273	if(newprefs01_alpha[i].Len()) {
		274	line=wxString::Format("%03d:",i);
		275	(void) fwrite((const char *) line, 1, 4, newprefs01_fd);
		276	(void) fwrite((const char *) newprefs01_alpha[i], 1, newprefs01_alpha[i].Len(), newprefs01_fd);
		277	(void) fwrite("\n", 1, 1, newprefs01_fd);
		278	}
		279	}
232	(void) fclose(newprefs01_fd);	280	(void) fclose(newprefs01_fd);
233	}	281	}
234	}	282	}
Lines 239-249 Link Here
239	#define WXOBEF (wxObjectEventFunction)&CFlowChart	287	#define WXOBEF (wxObjectEventFunction)&CFlowChart
240	for (int i = 1 ; i <= 100 ; i++)	288	for (int i = 1 ; i <= 100 ; i++)
241	{	289	{
242	newprefs01_opt[i] = 0;
243	newprefs03_opt[i] = 0;	290	newprefs03_opt[i] = 0;
244	newprefs04_opt[i] = 0;	291	newprefs04_opt[i] = 0;
245	}	292	}
246	//Save_NewPrefs01();
247	DARK_WHITE = new wxColour(0xef, 0xef, 0xef);	293	DARK_WHITE = new wxColour(0xef, 0xef, 0xef);
248	Load_NewPrefs01();	294	Load_NewPrefs01();
249	ReadOldPrefs();	295	ReadOldPrefs();
Lines 362-369 Link Here
362	wxBoxSizer *root = new wxBoxSizer(wxVERTICAL);	408	wxBoxSizer *root = new wxBoxSizer(wxVERTICAL);
363	this -> SetAutoLayout(TRUE);	409	this -> SetAutoLayout(TRUE);
364	this -> SetSizer(root);	410	this -> SetSizer(root);
365	root -> Fit(this);
366	root -> SetSizeHints(this);	411	root -> SetSizeHints(this);
		412	root -> Fit(this);
367	root -> Show(this, TRUE);	413	root -> Show(this, TRUE);
368	Connect( - 1, wxEVT_MOTION, SDMOUSEEVT:: OnMouseMove);	414	Connect( - 1, wxEVT_MOTION, SDMOUSEEVT:: OnMouseMove);
369	Connect( - 1, wxEVT_PAINT, SDPAINTEVT:: OnPaint);	415	Connect( - 1, wxEVT_PAINT, SDPAINTEVT:: OnPaint);
Lines 480-485 Link Here
480		526
481	CFlowChart:: ~CFlowChart()	527	CFlowChart:: ~CFlowChart()
482	{	528	{
		529	Save_NewPrefs01();
483	}	530	}
484		531
485	void CFlowChart:: Popup_NewPrefs(wxMouseEvent &event)	532	void CFlowChart:: Popup_NewPrefs(wxMouseEvent &event)
Lines 536-541 Link Here
536	{	583	{
537	if (x > 25 &&x < 130)	584	if (x > 25 &&x < 130)
538	{	585	{
		586	int p=0;wxString ps;
		587	ps=pop_newprefs01 -> GetLabel(20107);
		588	p=ps.Find(":");
		589	if(p) {
		590	ps=ps.Left(p+1);
		591	}
		592	pop_newprefs01 -> SetLabel(20107, ps+" "+newprefs01_alpha[7]);
539	PopupMenu(pop_newprefs01, event.GetPosition());	593	PopupMenu(pop_newprefs01, event.GetPosition());
540	}	594	}
541	else if(x > 141 &&x < 236)	595	else if(x > 141 &&x < 236)
Lines 564-569 Link Here
564	case 20104:	618	case 20104:
565	case 20105:	619	case 20105:
566	case 20106:	620	case 20106:
		621	case 20107:
567	if (pop_newprefs01 -> IsChecked(eventid))	622	if (pop_newprefs01 -> IsChecked(eventid))
568	{	623	{
569	newprefs01_opt[eventid - 20100] = 1;	624	newprefs01_opt[eventid - 20100] = 1;




#	include "ini2.h"
#	include "KnownFile.h"
#	include "KnownFileList.h"
#	include "NewFunctions.h"
#	include "opcodes.h"
#	include "otherfunctions.h"
#	include "PartFile.h"
#	include "Preferences.h"
#	include "SharedFileList.h"
#	include "SharedFilesWnd.h"

#include <sys/types.h>
#include <sys/stat.h>

// Adde by Tarod [Juanjo]
void CFileStatistic::AddRequest()
#define S12 7
#define S13 11
#define S14 19
#define S21 3
#define S22 5
#define S23 9
#define S24 13
#define S31 3
#define S32 9
#define S33 11
#define S34 15

static void MD4Transform(uint32 Hash[4], uint32 x[16]);

void CFileStatistic:: AddRequest()
{
    requested++;
    alltimerequested++;

    theApp.sharedfiles -> UpdateItem(fileParent);
}

void CFileStatistic::AddAccepted()
{
    accepted++;
    alltimeaccepted++;

    theApp.sharedfiles -> UpdateItem(fileParent);
}

void CFileStatistic::AddTransferred(uint64 bytes)
{
    transfered += bytes;
    alltimetransfered += bytes;

    theApp.sharedfiles -> UpdateItem(fileParent);
}

CKnownFile::CKnownFile()
{
    m_iFileType = 2;
    directory = NULL;

    m_iPartCount = 0;
}

CKnownFile::~ CKnownFile()
{
    for (int i = 0 ; i != hashlist.GetSize() ; i++)
    if (hashlist[i])

    m_AvailPartFrequency.RemoveAll();
}

CBarShader CKnownFile::s_ShareStatusBar(16);

void CKnownFile::DrawShareStatusBar(wxDC * dc, wxRect rect, bool onlygreyrect, bool bFlat)
{
 /*
 DWORD crBoth;
 DWORD crNeither;
 DWORD crClientOnly;
 DWORD crPending;
 DWORD crNextPending;
 if(bFlat) {
 crBoth = RGB(0, 150, 0);
 crNeither = RGB(224, 224, 224);
 crClientOnly = RGB(0, 0, 0);
 crPending = RGB(255,208,0);
 crNextPending = RGB(255,255,100);
 } else {
 crBoth = RGB(0, 192, 0);
 crNeither = RGB(240, 240, 240);
 crClientOnly = RGB(104, 104, 104);
 crPending = RGB(255, 208, 0);
 crNextPending = RGB(255,255,100);
 }
    */
    s_ShareStatusBar.SetFileSize(GetFileSize());
    s_ShareStatusBar.SetHeight(rect.GetHeight());
    s_ShareStatusBar.SetWidth(rect.GetWidth());

    s_ShareStatusBar.Draw(dc, rect.GetLeft(), rect.GetTop(), bFlat);
}

void CKnownFile::NewAvailPartsInfo()
{
    // Cache part count
    uint16 partcount = GetPartCount();

    {
        m_AvailPartFrequency.Add(0);
    }
    CUpDownClient * cur_src;
    if (this -> IsPartFile())
    cur_src = NULL;
    for (POSITION pos = m_ClientUploadList.GetHeadPosition() ; pos != 0 ;)

    theApp.xmuledlg -> sharedfileswnd -> sharedfilesctrl -> UpdateItem(this);
}

void CKnownFile::AddUploadingClient(CUpDownClient * client)
{
    // to be sure:
    POSITION pos = m_ClientUploadList.Find(client);

    }
}

void CKnownFile::RemoveUploadingClient(CUpDownClient * client)
{
    // to be sure:
    POSITION pos = m_ClientUploadList.Find(client);

    }
}

void CKnownFile::SetPath(char * path)
{
    if (directory)
    delete[] directory;
    directory = nstrdup(path);
}

bool CKnownFile::CreateFromFile(void * pf0, char * in_directory, char * in_filename, volatile int const * notify)
{
    CPartFile *pf;
    pf=(CPartFile *)pf0;
    m_isDynamic = 0;
    printf("CKnownFile::CreateFromFile: %s %s\n",in_directory, in_filename);
    directory = nstrdup(in_directory);
    char * namebuffer = new char[strlen(in_directory) + strlen(in_filename) + 2];
    sprintf(namebuffer, "%s/%s", in_directory, in_filename);
    FILE * file = fopen(namebuffer, "r");
    delete[] namebuffer;
    if (file)
    {
 	long curpos=0;
        printf("%s/%s  curpos=%u\n", in_directory, in_filename, curpos);
    }
    // set filesize + name
    m_pszFileName = nstrdup(in_filename);
        if (pf != NULL)
        {
            m_isDynamic = pf -> IsDynamic();
            m_nFileSize = pf -> m_nFileSize;
	    pf->Seek(curpos);
        }
        else
        {
            curpos = ftell(file);
    fseek(file, 0, SEEK_END);
    m_nFileSize = ftell(file);
    fseek(file, curpos, SEEK_SET);
        }
    m_AvailPartFrequency.SetSize(GetPartCount());
    for (uint32 i = 0 ; i != GetPartCount() ; i++)
        {
    m_AvailPartFrequency.Add(0);
        }
    // create hashset
    uint32 togo = m_nFileSize;
        uint16 hashcount=0;
        while(togo >= PARTSIZE)
        {
            uchar * newhash = new uchar[16];
            if (pf != NULL)
            {
                pf -> CreateHash(PARTSIZE, newhash);
            }
            else
    {
        uchar *newhash = new uchar[16];
        CreateHashFromFile(file, PARTSIZE, newhash);
            }
        hashlist.Add(newhash);
        togo -= PARTSIZE;
        hashcount++;
            if (notify && * notify)
            {
                if (pf == NULL)
        {
            fclose(file);
                }
            return false;
        }
    }
        uchar * lasthash = new uchar[16];
    memset(lasthash, 0, 16);
        if (pf != NULL)
        {
            pf -> CreateHash(togo, lasthash);
        }
        else
        {
            CreateHashFromFile( file, togo, lasthash);
        }
    if (!hashcount)
    {
        memcpy(m_abyFileHash, lasthash, 16);
        // i_a: memleak:
        delete[] lasthash;
    }
    else
    {
        hashlist.Add(lasthash);
            uchar * buffer = new uchar[hashlist.GetCount() * 16];
        for (int i = 0 ; i != hashlist.GetCount() ; i++)
            {
                memcpy(buffer + (i * 16), hashlist[i], 16);
            }
            CreateHashFromString(buffer, hashlist.GetCount() * 16, m_abyFileHash);
        delete[] buffer;
    }
    // TODO: Add filetags
    // set lastwrite date
    struct stat fileinfo;
        fstat(fileno(file), & fileinfo);
    date = fileinfo.st_mtime;
    //finished
    fclose(file);
    return true;
    }
    else
    {
        return false;
    }
}

bool CKnownFile::LoadHashsetFromFile(CFile * file, bool checkhash)
bool CKnownFile:: LoadHashsetFromFile(CFile *file, bool checkhash)
{
    uchar checkid[16];
    file -> Read( & checkid, 16);
    uint16 parts;
    file -> Read( & parts, 2);
    for (int i = 0 ; i != parts ; i++)
    {
        uchar * cur_hash = new uchar[16];
        file -> Read(cur_hash, 16);
        hashlist.Add(cur_hash);
    }

    // trust noone ;-)
    if (!hashlist.IsEmpty())
    {
        uchar * buffer = new uchar[hashlist.GetCount() * 16];
        for (int i = 0 ; i != hashlist.GetCount() ; i++)
        {
            memcpy(buffer + (i * 16), hashlist[i], 16);
        }
        CreateHashFromString(buffer, hashlist.GetCount() * 16, checkid);
        delete[] buffer;
    }
    if (!memcmp(m_abyFileHash, checkid, 16))

    }
}

bool CKnownFile::LoadTagsFromFile(CFile * file)
{
    try
    {
        uint32 tagcount;
        if (4 != file -> Read( & tagcount, 4))
        throw CInvalidPacket("short file reading tag count");
        for (uint32 j = 0 ; j < tagcount ; j++)
        {
            try
            {
                CTag * newtag = new CTag(file);
                switch (newtag -> tag -> specialtag)
                {
                case FT_FILENAME:

    return true;
}

bool CKnownFile::LoadDateFromFile(CFile * file)
{
    return(4 == file -> Read( & date, 4));
}

bool CKnownFile::LoadFromFile(CFile * file)
{
    return(LoadDateFromFile(file) && LoadHashsetFromFile(file, false) && LoadTagsFromFile(file));
}

bool CKnownFile::WriteToFile(FILE * file)
{
    // date
    fwrite( & date, 4, 1, file);
    // hashset
    fwrite( & m_abyFileHash, 16, 1, file);
    uint16 parts = hashlist.GetCount();
    fwrite( & parts, 2, 1, file);
    for (int i = 0 ; i != parts ; i++)
    fwrite(hashlist[i], 16, 1, file);
    //tags
#define NR_TAGS 10
    uint32 tagcount = taglist.GetCount() + NR_TAGS;
    // standard tags
    fwrite( & tagcount, 4, 1, file);
    CTag(FT_FILENAME, m_pszFileName) .WriteTagToFile(file);
    CTag(FT_FILESIZE, m_nFileSize) .WriteTagToFile(file);
    // statistic

#undef NR_TAGS
}

void CKnownFile::CreateHashFromFile( FILE * file, int Length, uchar * Output)
{
    if (file != NULL)
    {
        bool PaddingStarted = false;
        uint32 Hash[4];
        Hash[0] = 0x67452301;
        Hash[1] = 0xEFCDAB89;
        Hash[2] = 0x98BADCFE;
        Hash[3] = 0x10325476;
        uint32 Required = Length;
        uchar X[64 * 128];
        while (Required >= 64)
        {
            uint32 len = Required / 64;
            if (len > sizeof(X) / (64 * sizeof(X[0])))
            {
                len = sizeof(X) / (64 * sizeof(X[0]));
            }
            fread( & X, len * 64, 1, file);
            for (uint32 i = 0 ; i < len ; i++)
            {
                MD4Transform(Hash, (uint32 *)(X + i * 64));
            }
            Required -= len * 64;
        }
        // bytes to read
        Required = Length % 64;
        if (Required != 0)
        {
            fread( & X, Required, 1, file);
        }
        // in byte scale 512 = 64, 448 = 56
        if (Required >= 56)
        {
            X[Required] = 0x80;
            PaddingStarted = TRUE;
            memset( & X[Required + 1], 0, 63 - Required);
            MD4Transform(Hash, (uint32 *) X);
            Required = 0;
        }
        if (!PaddingStarted)
        {
            X[Required++] = 0x80;
        }
        memset( & X[Required], 0, 64 - Required);
        // add size (convert to bits)
        uint32 Length2 = Length >> 29;
        Length <<= 3;
        memcpy( & X[56], & Length, 4);
        memcpy( & X[60], & Length2, 4);
        MD4Transform(Hash, (uint32 *) X);
        memcpy(Output, Hash, 16);
    }
}

void CKnownFile::CreateHashFromInput(int id, FILE * file, CFile * file2, int Length, uchar * Output, uchar * in_string)
{
    // time critial
    bool PaddingStarted = false;

    Hash[1] = 0xEFCDAB89;
    Hash[2] = 0x98BADCFE;
    Hash[3] = 0x10325476;
    CMemFile * data = 0;
    if (in_string)
    {
        data = new CMemFile(in_string, Length);
    }
    uint32 Required = Length;
    uchar X[64 * 128];
    while (Required >= 64)
    {
        uint32 len = Required / 64;
        if (len > sizeof(X) / (64 * sizeof(X[0])))
        len = sizeof(X) / (64 * sizeof(X[0]));
        if (in_string)
        {
            data -> Read( & X, len * 64);
        }
        else if(file)
        {
            fread( & X, len * 64, 1, file);
        }
        else if(file2)
        {
            file2 -> Read( & X, len * 64);
        }
        for (uint32 i = 0 ; i < len ; i++)
        {
            MD4Transform(Hash, (uint32 *)(X + i * 64));
        }
        Required -= len * 64;
    }
    // bytes to read
    Required = Length % 64;
    if (Required != 0)
    {
        if (in_string)
        {
            data -> Read( & X, Required);
        }
        else if(file)
        {
            fread( & X, Required, 1, file);
        }
        else if(file2)
        {
            file2 -> Read( & X, Required);
        }
    }
    // in byte scale 512 = 64, 448 = 56
    if (Required >= 56)
    {
        X[Required] = 0x80;
        PaddingStarted = TRUE;
        memset( & X[Required + 1], 0, 63 - Required);
        MD4Transform(Hash, (uint32 *) X);
        Required = 0;
    }

    {
        X[Required++] = 0x80;
    }
    memset( & X[Required], 0, 64 - Required);
    // add size (convert to bits)
    uint32 Length2 = Length >> 29;
    Length <<= 3;
    memcpy( & X[56], & Length, 4);
    memcpy( & X[60], & Length2, 4);
    MD4Transform(Hash, (uint32 *) X);
    memcpy(Output, Hash, 16);
    safe_delete(data);
}

uchar * CKnownFile::GetPartHash(uint16 part)
{
    if (part >= hashlist.GetCount())
    {
    return 0;
    }
    return hashlist[part];
}

void CAbstractFile::SetFileName(char * NewName)
{
    uint32 a = Hash[0];
    uint32 b = Hash[1];
    uint32 c = Hash[2];
    uint32 d = Hash[3];
    /* Round 1 */
    // 01:
    MD4_FF(a, b, c, d, x[ 0], S11);
    // 02:
    MD4_FF(d, a, b, c, x[ 1], S12);
    // 03:
    MD4_FF(c, d, a, b, x[ 2], S13);
    // 04:
    MD4_FF(b, c, d, a, x[ 3], S14);
    // 05:
    MD4_FF(a, b, c, d, x[ 4], S11);
    // 06:
    MD4_FF(d, a, b, c, x[ 5], S12);
    // 07:
    MD4_FF(c, d, a, b, x[ 6], S13);
    // 08:
    MD4_FF(b, c, d, a, x[ 7], S14);
    // 09:
    MD4_FF(a, b, c, d, x[ 8], S11);
    // 10:
    MD4_FF(d, a, b, c, x[ 9], S12);
    // 11:
    MD4_FF(c, d, a, b, x[10], S13);
    // 12:
    MD4_FF(b, c, d, a, x[11], S14);
    // 13:
    MD4_FF(a, b, c, d, x[12], S11);
    // 14:
    MD4_FF(d, a, b, c, x[13], S12);
    // 15:
    MD4_FF(c, d, a, b, x[14], S13);
    // 16:
    MD4_FF(b, c, d, a, x[15], S14);
    /* Round 2 */
    // 17:
    MD4_GG(a, b, c, d, x[ 0], S21);
    // 18:
    MD4_GG(d, a, b, c, x[ 4], S22);
    // 19:
    MD4_GG(c, d, a, b, x[ 8], S23);
    // 20:
    MD4_GG(b, c, d, a, x[12], S24);
    // 21:
    MD4_GG(a, b, c, d, x[ 1], S21);
    // 22:
    MD4_GG(d, a, b, c, x[ 5], S22);
    // 23:
    MD4_GG(c, d, a, b, x[ 9], S23);
    // 24:
    MD4_GG(b, c, d, a, x[13], S24);
    // 25:
    MD4_GG(a, b, c, d, x[ 2], S21);
    // 26:
    MD4_GG(d, a, b, c, x[ 6], S22);
    // 27:
    MD4_GG(c, d, a, b, x[10], S23);
    // 28:
    MD4_GG(b, c, d, a, x[14], S24);
    // 29:
    MD4_GG(a, b, c, d, x[ 3], S21);
    // 30:
    MD4_GG(d, a, b, c, x[ 7], S22);
    // 31:
    MD4_GG(c, d, a, b, x[11], S23);
    // 32:
    MD4_GG(b, c, d, a, x[15], S24);
    /* Round 3 */
    // 33:
    MD4_HH(a, b, c, d, x[ 0], S31);
    // 34:
    MD4_HH(d, a, b, c, x[ 8], S32);
    // 35:
    MD4_HH(c, d, a, b, x[ 4], S33);
    // 36:
    MD4_HH(b, c, d, a, x[12], S34);
    // 37:
    MD4_HH(a, b, c, d, x[ 2], S31);
    // 38:
    MD4_HH(d, a, b, c, x[10], S32);
    // 39:
    MD4_HH(c, d, a, b, x[ 6], S33);
    // 40:
    MD4_HH(b, c, d, a, x[14], S34);
    // 41:
    MD4_HH(a, b, c, d, x[ 1], S31);
    // 42:
    MD4_HH(d, a, b, c, x[ 9], S32);
    // 43:
    MD4_HH(c, d, a, b, x[ 5], S33);
    // 44:
    MD4_HH(b, c, d, a, x[13], S34);
    // 45:
    MD4_HH(a, b, c, d, x[ 3], S31);
    // 46:
    MD4_HH(d, a, b, c, x[11], S32);
    // 47:
    MD4_HH(c, d, a, b, x[ 7], S33);
    // 48:
    MD4_HH(b, c, d, a, x[15], S34);
    Hash[0] += a;
    Hash[1] += b;
    Hash[2] += c;
    Hash[3] += d;
}

// Adde by Tarod [Juanjo]
void CAbstractFile:: SetFileName(char *NewName)
{
    if (m_pszFileName != NULL)
    {


//End by Tarod

Packet * CKnownFile::CreateSrcInfoPacket(CUpDownClient * forClient)
{
    CTypedPtrList <CPtrList, CUpDownClient *> srclist;
    //should we use "filehash"?:
    theApp.uploadqueue -> FindSourcesForFileById( & srclist, forClient -> GetUploadFileID());
    if (srclist.IsEmpty())
    return 0;
    CMemFile data;
    uint16 nCount = 0;
    data.Write(forClient -> GetUploadFileID(), 16);
    data.Write( & nCount, 2);
    uint32 lastRequest = forClient -> GetLastSrcReqTime();
    //we are only taking 30 random sources since we can't be sure if they have parts we need
    //this is hard coded because its a temp solution until next(?) version

    {
        int victim = ((rand() >> 7) % srclist.GetSize());
        POSITION pos = srclist.FindIndex(victim);
        CUpDownClient * cur_src = srclist.GetAt(pos);
        if (!cur_src -> HasLowID() && cur_src != forClient)
        {
            nCount++;
            uint32 dwID = cur_src -> GetUserID();
            uint16 nPort = cur_src -> GetUserPort();
            uint32 dwServerIP = cur_src -> GetServerIP();
            uint16 nServerPort = cur_src -> GetServerPort();
            data.Write( & dwID, 4);
            data.Write( & nPort, 2);
            data.Write( & dwServerIP, 4);
            data.Write( & nServerPort, 2);
            if (forClient -> GetSourceExchangeVersion() > 1)
            data.Write(cur_src -> GetUserHash(), 16);
        }

    if (!nCount)
    return 0;
    data.Seek(16);
    data.Write( & nCount, 2);
    Packet * result = new Packet( & data, OP_EMULEPROT);
    result -> opcode = OP_ANSWERSOURCES;
    if (nCount > 28)
    result -> PackPacket();

}

// Updates priority of file if autopriority is activated
void CKnownFile::UpdateAutoUpPriority(void)
{
    if (!this -> IsAutoUpPriority())
    return;

}

//For File Comment //
void CKnownFile::LoadComment()
{
    char buffer[100];
    char * fullpath = new char[strlen(theApp.glob_prefs -> GetAppDir()) + 13];
    sprintf(fullpath, "%sfileinfo.ini", theApp.glob_prefs -> GetAppDir());
    buffer[0] = 0;
    for (uint16 i = 0 ; i != 16 ; i++)

    delete[] fullpath;
}

void CKnownFile::SetFileComment(CString strNewComment)
{
    char buffer[100];
    char * fullpath = new char[strlen(theApp.glob_prefs -> GetAppDir()) + 13];
    sprintf(fullpath, "%sfileinfo.ini", theApp.glob_prefs -> GetAppDir());
    buffer[0] = 0;
    for (uint16 i = 0 ; i != 16 ; i++)

    ini.WriteString("Comment", strNewComment);
    m_strComment = strNewComment;
    delete fullpath;
    CTypedPtrList <CPtrList, CUpDownClient *> srclist;
    theApp.uploadqueue -> FindSourcesForFileById( & srclist, this -> GetFileHash());
    for (POSITION pos = srclist.GetHeadPosition() ; pos != 0 ; srclist.GetNext(pos))
    {
        CUpDownClient * cur_src = srclist.GetAt(pos);
        cur_src -> SetCommentDirty();
    }
}

// For File rate
void CKnownFile::SetFileRate(int8 iNewRate)
{
    char buffer[100];
    char * fullpath = new char[strlen(theApp.glob_prefs -> GetAppDir()) + 13];
    sprintf(fullpath, "%sfileinfo.ini", theApp.glob_prefs -> GetAppDir());
    buffer[0] = 0;
    for (uint16 i = 0 ; i != 16 ; i++)

    ini.WriteInt("Rate", iNewRate);
    m_iRate = iNewRate;
    delete fullpath;
    CTypedPtrList <CPtrList, CUpDownClient *> srclist;
    theApp.uploadqueue -> FindSourcesForFileById( & srclist, this -> GetFileHash());
    for (POSITION pos = srclist.GetHeadPosition() ; pos != 0 ; srclist.GetNext(pos))
    {
        CUpDownClient * cur_src = srclist.GetAt(pos);
        cur_src -> SetCommentDirty();
    }
}

void CKnownFile::SetUpPriority(uint8 iNewUpPriority, bool m_bsave)
{
    m_iUpPriority = iNewUpPriority;
    if (this -> IsPartFile() && m_bsave)
    ((CPartFile *) this) -> SavePartFile();
}





	CKnownFile();
	~CKnownFile();

	virtual bool	CreateFromFile(void* pf,char* directory,char* filename, volatile int const * notify); // create date, hashset and tags from a file
	uint32*	GetFileTypePtr()		{return &m_iFileType;}
	char*	GetPath()				{return directory;}
	void	SetPath(char* path);

protected:
	bool	LoadTagsFromFile(CFile* file);
	bool	LoadDateFromFile(CFile* file);
	void	CreateHashFromFile(FILE* file, int Length, uchar* Output);
	void	CreateHashFromString(uchar* in_string, int Length, uchar* Output)	{CreateHashFromInput(0,0,0,Length,Output,in_string);}
	void	CreateHashFromString(uchar* in_string, int Length, uchar* Output)	{CreateHashFromInput(0,0,Length,Output,in_string);}
	void	LoadComment();//comment
	CArray<uchar*,uchar*> hashlist;
	CArray<CTag*,CTag*> taglist;
	char*	directory;

private:
	void	CreateHashFromInput(int id,FILE* file,CFile* file2, int Length, uchar* Output, uchar* = 0);
	bool	m_bCommentLoaded;
	uint16	m_iPartCount;
        uint16  m_iED2KPartCount;

	uint32	m_iQueuedCount;
	static	CBarShader s_ShareStatusBar;
	bool	m_PublishedED2K;
	int	m_isDynamic;
	long	m_hfilepos;

public:
	time_t	m_nCompleteSourcesTime;

#define PERM_NOONE		2


// basic MD4 functions
#define MD4_F(x, y, z) (((x) & (y)) | ((~x) & (z)))
#define MD4_G(x, y, z) (((x) & (y)) | ((x) & (z)) | ((y) & (z)))
#define MD4_H(x, y, z) ((x) ^ (y) ^ (z))

// rotates x left n bits
#define MD4_ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))

// partial transformations
#define MD4_FF(a, b, c, d, x, s) \
{ \
  (a) += MD4_F((b), (c), (d)) + (x); \
  (a) = MD4_ROTATE_LEFT((a), (s)); \
}

#define MD4_GG(a, b, c, d, x, s) \
{ \
  (a) += MD4_G((b), (c), (d)) + (x) + (uint32)0x5A827999; \
  (a) = MD4_ROTATE_LEFT((a), (s)); \
}

#define MD4_HH(a, b, c, d, x, s) \
{ \
  (a) += MD4_H((b), (c), (d)) + (x) + (uint32)0x6ED9EBA1; \
  (a) = MD4_ROTATE_LEFT((a), (s)); \
}


#endif

Lines 34-44 Link Here

(-)xmule/src/NewFunctions.cpp (+135 lines)
34	#include "NewFunctions.h"	34	#include "NewFunctions.h"
35	#include "otherfunctions.h"	35	#include "otherfunctions.h"
36		36
		37
		38	void MD4Transform(uint32 Hash[4], uint32 x[16])
		39	{
		40	// constants for MD4Transform
		41	#define S11 3
		42	#define S12 7
		43	#define S13 11
		44	#define S14 19
		45	#define S21 3
		46	#define S22 5
		47	#define S23 9
		48	#define S24 13
		49	#define S31 3
		50	#define S32 9
		51	#define S33 11
		52	#define S34 15
		53
		54	uint32 a = Hash[0];
		55	uint32 b = Hash[1];
		56	uint32 c = Hash[2];
		57	uint32 d = Hash[3];
		58	/* Round 1 */
		59	// 01:
		60	MD4_FF(a, b, c, d, x[0], S11);
		61	// 02:
		62	MD4_FF(d, a, b, c, x[1], S12);
		63	// 03:
		64	MD4_FF(c, d, a, b, x[2], S13);
		65	// 04:
		66	MD4_FF(b, c, d, a, x[3], S14);
		67	// 05:
		68	MD4_FF(a, b, c, d, x[4], S11);
		69	// 06:
		70	MD4_FF(d, a, b, c, x[5], S12);
		71	// 07:
		72	MD4_FF(c, d, a, b, x[6], S13);
		73	// 08:
		74	MD4_FF(b, c, d, a, x[7], S14);
		75	// 09:
		76	MD4_FF(a, b, c, d, x[8], S11);
		77	// 10:
		78	MD4_FF(d, a, b, c, x[9], S12);
		79	// 11:
		80	MD4_FF(c, d, a, b, x[10], S13);
		81	// 12:
		82	MD4_FF(b, c, d, a, x[11], S14);
		83	// 13:
		84	MD4_FF(a, b, c, d, x[12], S11);
		85	// 14:
		86	MD4_FF(d, a, b, c, x[13], S12);
		87	// 15:
		88	MD4_FF(c, d, a, b, x[14], S13);
		89	// 16:
		90	MD4_FF(b, c, d, a, x[15], S14);
		91	/* Round 2 */
		92	// 17:
		93	MD4_GG(a, b, c, d, x[0], S21);
		94	// 18:
		95	MD4_GG(d, a, b, c, x[4], S22);
		96	// 19:
		97	MD4_GG(c, d, a, b, x[8], S23);
		98	// 20:
		99	MD4_GG(b, c, d, a, x[12], S24);
		100	// 21:
101	MD4_GG(a, b, c, d, x[1], S21);
102	// 22:
103	MD4_GG(d, a, b, c, x[5], S22);
104	// 23:
105	MD4_GG(c, d, a, b, x[9], S23);
106	// 24:
107	MD4_GG(b, c, d, a, x[13], S24);
108	// 25:
109	MD4_GG(a, b, c, d, x[2], S21);
110	// 26:
111	MD4_GG(d, a, b, c, x[6], S22);
112	// 27:
113	MD4_GG(c, d, a, b, x[10], S23);
114	// 28:
115	MD4_GG(b, c, d, a, x[14], S24);
116	// 29:
117	MD4_GG(a, b, c, d, x[3], S21);
118	// 30:
119	MD4_GG(d, a, b, c, x[7], S22);
120	// 31:
121	MD4_GG(c, d, a, b, x[11], S23);
122	// 32:
123	MD4_GG(b, c, d, a, x[15], S24);
124	/* Round 3 */
125	// 33:
126	MD4_HH(a, b, c, d, x[0], S31);
127	// 34:
128	MD4_HH(d, a, b, c, x[8], S32);
129	// 35:
130	MD4_HH(c, d, a, b, x[4], S33);
131	// 36:
132	MD4_HH(b, c, d, a, x[12], S34);
133	// 37:
134	MD4_HH(a, b, c, d, x[2], S31);
135	// 38:
136	MD4_HH(d, a, b, c, x[10], S32);
137	// 39:
138	MD4_HH(c, d, a, b, x[6], S33);
139	// 40:
140	MD4_HH(b, c, d, a, x[14], S34);
141	// 41:
142	MD4_HH(a, b, c, d, x[1], S31);
143	// 42:
144	MD4_HH(d, a, b, c, x[9], S32);
145	// 43:
146	MD4_HH(c, d, a, b, x[5], S33);
147	// 44:
148	MD4_HH(b, c, d, a, x[13], S34);
149	// 45:
150	MD4_HH(a, b, c, d, x[3], S31);
151	// 46:
152	MD4_HH(d, a, b, c, x[11], S32);
153	// 47:
154	MD4_HH(c, d, a, b, x[7], S33);
155	// 48:
156	MD4_HH(b, c, d, a, x[15], S34);
157	Hash[0] += a;
158	Hash[1] += b;
159	Hash[2] += c;
160	Hash[3] += d;
161	}
162
37	uint32 MapData(MAP *pos)	163	uint32 MapData(MAP *pos)
38	{	164	{
39	return pos -> Data;	165	return pos -> Data;
40	}	166	}
41		167
		168	void md4printf(const void *hash)
		169	{
		170	printf("md4hash: ");
		171	for(int i=0;i<16;i++) {
		172	printf("%02x",((unsigned char *)hash)[i]);
		173	}
		174	printf("\n");
		175	}
		176
42	unsigned char MapDataKey(MAP pos)	177	unsigned char MapDataKey(MAP pos)
43	{	178	{
44	return pos -> Key;	179	return pos -> Key;





#define		MAPCLIENTS_MAX		30000

// basic MD4 functions
#define MD4_F(x, y, z) (((x) & (y)) | ((~x) & (z)))
#define MD4_G(x, y, z) (((x) & (y)) | ((x) & (z)) | ((y) & (z)))
#define MD4_H(x, y, z) ((x) ^ (y) ^ (z))

// rotates x left n bits
#define MD4_ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))

// partial transformations
#define MD4_FF(a, b, c, d, x, s) \
{ \
  (a) += MD4_F((b), (c), (d)) + (x); \
  (a) = MD4_ROTATE_LEFT((a), (s)); \
}

#define MD4_GG(a, b, c, d, x, s) \
{ \
  (a) += MD4_G((b), (c), (d)) + (x) + (uint32)0x5A827999; \
  (a) = MD4_ROTATE_LEFT((a), (s)); \
}

#define MD4_HH(a, b, c, d, x, s) \
{ \
  (a) += MD4_H((b), (c), (d)) + (x) + (uint32)0x6ED9EBA1; \
  (a) = MD4_ROTATE_LEFT((a), (s)); \
}
void MD4Transform(uint32 Hash[4],uint32 x[16]);
void md4printf(const void *hash);

typedef struct _MAP
{
	_MAP*	next;




#	include "DownloadQueue.h"
#	include "ED2KLink.h"
#	include "ini2.h"
#	include "NewFunctions.h"
#	include "otherfunctions.h"
#	include "PartFile.h"
#	include "Preview.h"

#include <arpa/inet.h>

#include <wx/filename.h>
#include <wx/file.h>

#define min(a,b) ((a)<(b)?(a):(b))
#define PROGRESS_HEIGHT 3

void dump16f(FILE * f, uchar * d16)
{
    int i;
    for (i = 0 ; i < 16 ; i++)
    {
        fprintf(f, "%02X", * d16++);
    }
}

void dump16(uchar * d16)
{
    int i;
    for (i = 0 ; i < 16 ; i++)
    {
        printf("%02X", * d16++);
    }
}

extern void dump16(uchar *);

int bsize = 128 * 1024;
unsigned char buffer1[128 * 1024 + 1];

CBarShader CPartFile::s_LoadBar(PROGRESS_HEIGHT);

CBarShader CPartFile::s_ChunkBar(16);

CPartFile::CPartFile()
{
    Init();
}

CPartFile::CPartFile(CSearchFile * searchresult)
{
    Init();
    memcpy(m_abyFileHash, searchresult -> GetFileHash(), 16);

                break;
            }
        default:
            CTag * newtag = new CTag(searchresult -> taglist[i] -> tag);
            taglist.Add(newtag);
        }
    }
    m_hfilepos = 0;
    if (newprefs01_opt[5])
    {
        m_isDynamic |= 3;
        m_nHeaderLength = (m_nFileSize/ bsize + 1) * 8;
        m_nDynBloCount = 0;
    }
    else
    {
        m_isDynamic = 0;
        m_nHeaderLength = 0;
        m_nDynBloCount = 0;
    }
    CreatePartFile();
}

CPartFile::CPartFile(wxString edonkeylink)
{
    CED2KLink * pLink = 0;
    pLink = CED2KLink::CreateLinkFromUrl(edonkeylink);
    CED2KFileLink * pFileLink = pLink -> GetFileLink();
        pLink = CED2KLink:: CreateLinkFromUrl(edonkeylink);
        CED2KFileLink *pFileLink = pLink -> GetFileLink();
        if (pFileLink == 0)
        throw GetResString(IDS_ERR_NOTAFILELINK);
        InitializeFromLink(pFileLink);
    }
    catch(wxString error)
    {
        char buffer[200];
        sprintf(buffer, GetResString(IDS_ERR_INVALIDLINK), error.GetData());
        theApp.xmuledlg -> AddLogLine(true, GetResString(IDS_ERR_LINKERROR), buffer);
        SetPartFileStatus(PS_ERROR);
    }
    delete pLink;
}

void
CPartFile::InitializeFromLink(CED2KFileLink * fileLink)
{
    Init();
    m_pszFileName = nstrdup(fileLink -> GetName());
    m_nFileSize = fileLink -> GetSize();
    memcpy(m_abyFileHash, fileLink -> GetHashKey(), sizeof(m_abyFileHash));
    if (!theApp.downloadqueue -> IsFileExisting(m_abyFileHash))
    {
    CreatePartFile();
    }
    else
    {
    SetPartFileStatus(PS_ERROR);
    }
}

CPartFile::CPartFile(CED2KFileLink * fileLink)
{
    InitializeFromLink(fileLink);
}

void CPartFile::Init()
{
    fullname = 0;
    newdate = true;
    lastsearchtime = 0;
    lastpurgetime =::GetTickCount();
    paused = false;
    stopped = false;
    SetPartFileStatus(PS_EMPTY);

    hashsetneeded = true;
    count = 0;
    percentcompleted = 0;
    partmetfilename = "";
    completedsize = 0;
    isnewstyle = false;
    partmettype = PMT_UNKNOWN;
    m_bPreviewing = false;
    //NULL;:
    lastseencomplete = 0;

    m_category = 0;
    m_lastRefreshedDLDisplay = 0;
    m_LastSourceDropTime = 0;
    m_isDynamic = 0;
    m_nHeaderLength = 0;
    m_nDynBloCount = 0;
    m_nFileSize = 0;
    convertstate=0;
}

CPartFile::~ CPartFile()
{
    // Barry - Ensure all buffered data is written
    FlushBuffer();
    //m_hpartfile.Flush();
    //SavePartFile();
    //m_hpartfile.Close();
    if (fullname)
    {
    delete[] fullname;
    }
    delete[] partmetfilename;
    m_SrcpartFrequency.RemoveAll();
    for (POSITION pos = gaplist.GetHeadPosition() ; pos != 0 ; gaplist.GetNext(pos))
    {
    delete gaplist.GetAt(pos);
    }
}

long CPartFile:: Read(void * buffer, long bytes)
{
    unsigned char tag[8];
    long bytecount = 0;
    if (IsDynamic() < 2)
    {
        bytecount = m_hpartfile.Read(buffer, bytes);
        m_hfilepos += bytecount;
    }
    else
    {
        unsigned long tag_number = 0, tag_blpo = 0;
        int tag_blnr, tag_bytes, filesize;
        unsigned char * bufferpos;
        bufferpos = (unsigned char *) buffer;
        if ((bytes + m_hfilepos) > m_nFileSize)
        {
            bytes = m_nFileSize - m_hfilepos;
            if (bytes < 0)
            {
                bytes = 0;
            }
        }
        while (bytecount < bytes)
        {
            tag_number = m_hfilepos/ bsize;
            tag_blpo = m_hfilepos - bsize * tag_number;
            tag_bytes = bsize - tag_blpo;
            if (tag_bytes > (bytes - bytecount))
            {
                tag_bytes = bytes - bytecount;
            }
            m_hpartfile.Readpos( & tag_blnr, tag_number * 8, 4);
            m_hpartfile.Readpos( & filesize, tag_number * 8 + 4, 4);
            if (tag_blnr)
            {
                tag_bytes = m_hpartfile.Readpos(bufferpos, m_nHeaderLength + (tag_blnr - 1) * bsize + tag_blpo, tag_bytes);
            }
            else
            {
                for (int i = 0 ; i < tag_bytes ; i++)
                {
                    bufferpos[i] = 0;
                }
            }
            if (tag_bytes)
            {
                m_hfilepos += tag_bytes;
                bufferpos += tag_bytes;
                bytecount += tag_bytes;
            }
            else
            {
                bytecount = bytes;
            }
        }
        bytecount = bytes;
    }
    return bytecount;
}

bool CPartFile:: Store(const wxString & newname)
{
    unsigned char * buffer;
    int tag_number = 0;
    int next = 0;
    long bytepos = 0, bytes = 0;
    wxFile fileOut(newname, wxFile:: write);
    while (bytepos < m_nFileSize)
    {
        buffer = buffer1;
        bytes = bsize;
        if ((bytepos + bytes) > m_nFileSize)
        {
            bytes = m_nFileSize - bytepos;
        }
        m_hpartfile.Readpos( & next, tag_number * 8, 4);
        (void) m_hpartfile.Readpos(buffer1, m_nHeaderLength + (next - 1) * bsize, bytes);
        while (bytes > 0)
        {
            if (bytes > 4095)
            {
                fileOut.Write(buffer, 4096);
                buffer += 4096;
                bytes -= 4096;
            }
            else
            {
                fileOut.Write(buffer, bytes);
                buffer += bytes;
                bytes = 0;
            }
        }
        tag_number++;
        bytepos += bsize;
    }
    (void) fileOut.Close();
    return true;
}

long CPartFile:: Write(void * buffer, long bytes)
{
    unsigned char tag[8];
    long bytecount = 0;
    if (IsDynamic() < 2)
    {
        m_hfilepos += bytes;
        if (Length() <= (m_hfilepos - 1))
        {
            ftruncate(m_hpartfile.fd(), m_hfilepos);
        }
        bytecount = m_hpartfile.Write(buffer, bytes);
    }
    else
    {
        unsigned long tag_number = 0, tag_blpo = 0;
        int tag_blnr, tag_bytes, filesize;
        unsigned char * bufferpos;
        bufferpos = (unsigned char *) buffer;
        bytecount = bytes;
        while (bytecount > 0)
        {
            tag_number = m_hfilepos/ bsize;
            tag_blpo = m_hfilepos - bsize * tag_number;
            tag_bytes = bsize - tag_blpo;
            if (tag_bytes > bytecount)
            {
                tag_bytes = bytecount;
            }
            m_hpartfile.Readpos( & tag_blnr, tag_number * 8, 4);
            m_hpartfile.Readpos( & filesize, tag_number * 8 + 4, 4);
            if (!tag_blnr)
            {
                m_nDynBloCount++;
                tag_blnr = m_nDynBloCount;
                m_hpartfile.Writepos( & tag_blnr, tag_number * 8, 4);
                ftruncate(m_hpartfile.fd(), m_nHeaderLength + tag_blnr * bsize);
            }
            tag_bytes = m_hpartfile.Writepos(bufferpos, m_nHeaderLength + (tag_blnr - 1) * bsize + tag_blpo, tag_bytes);
            if (tag_bytes)
            {
                m_hfilepos += tag_bytes;
                if (m_hfilepos > m_ilength)
                {
                    m_ilength = m_hfilepos;
                }
                bufferpos += tag_bytes;
                bytecount -= tag_bytes;
                if (filesize < m_hfilepos)
                {
                    filesize = m_hfilepos;
                    m_hpartfile.Writepos( & filesize, tag_number * 8 + 4, 4);
                }
            }
            else
            {
                bytecount = - bytecount;
            }
        }
        if (bytecount < 0)
        {
            bytecount = - bytecount;
        }
    }
    return bytecount;
}

void CPartFile::Seek(unsigned long filepos)
{
    if (IsDynamic() < 2)
    {
        m_hpartfile.Seek(filepos);
    }
    m_hfilepos = filepos;
}

void CPartFile::Close()
{
    m_hpartfile.Close();
}

unsigned long CPartFile::Length()
{
    unsigned long result;
    result = m_hpartfile.Length();
    if (IsDynamic() > 1)
    {
        m_nHeaderLength = (m_nFileSize/ bsize + 1) * 8;
        result -= m_nHeaderLength;
    }
    else
    {
        m_nHeaderLength = 0;
    }
    return result;
}

void CPartFile::CreatePartFile()
{
    // use lowest free partfilenumber for free file (InterCeptor)
    int i = 0;
    wxString filename;
    do
    {
        i++;
        if (newprefs01_opt[5])
        {
            filename = wxString::Format("%s/%03i.pnew", theApp.glob_prefs -> GetTempDir(), i);
        }
        else
        {
            filename = wxString::Format("%s/%03i.part", theApp.glob_prefs -> GetTempDir(), i);
        }
    }
    while (wxFileName::FileExists(filename));
    partmetfilename = new char[15];
    if (newprefs01_opt[5])
    {
        partmetfilename = wxString:: Format("%03i.pnew.met", i);
    }
    else
    {
        partmetfilename = wxString:: Format("%03i.part.met", i);
    }
    fullname = new char[strlen(theApp.glob_prefs -> GetTempDir()) + partmetfilename.Len() + MAX_PATH];
    sprintf(fullname, "%s/%s", theApp.glob_prefs -> GetTempDir(), partmetfilename.GetData());
    char * buffer = nstrdup(partmetfilename.GetData());
    buffer[strlen(buffer) - 4] = 0;
    CTag * partnametag = new CTag(FT_PARTFILENAME, buffer);
    delete[] buffer;
    taglist.Add(partnametag);
    Gap_Struct * gap = new Gap_Struct;
    gap -> start = 0;
    gap -> end = m_nFileSize - 1;
    gaplist.AddTail(gap);
    char * partfull = nstrdup(fullname);
    partfull[strlen(partfull) - 4] = 0;
    if (m_hpartfile.Create(partfull, TRUE))
    if (!m_hpartfile.Create(partfull, TRUE))
    {
        Close();
        if (m_hpartfile.Open(partfull, CFile::read_write))
        {
            if (newprefs01_opt[5])
            {
                m_nHeaderLength = (m_nFileSize/ bsize + 1) * 8;
                m_isDynamic |= 3;
                unsigned char * pfdyn_header;
                pfdyn_header = (unsigned char *) malloc(m_nHeaderLength);
                for (int i = 0 ; i < m_nHeaderLength ; i++)
                {
                    pfdyn_header[i] = 0;
    }
                m_hpartfile.Write(pfdyn_header, m_nHeaderLength);
                free(pfdyn_header);
            }
            else
    {
                m_nHeaderLength = 0;
                m_isDynamic = 0;
    }
    delete[] partfull;
    m_SrcpartFrequency.SetSize(GetPartCount());

    }
    paused = false;
    SavePartFile(true);
        }
        else
        {
            theApp.xmuledlg -> AddLogLine(false, GetResString(IDS_ERR_CREATEPARTFILE));
            SetPartFileStatus(PS_ERROR);
        }
    }
    else
    {
        theApp.xmuledlg -> AddLogLine(false, GetResString(IDS_ERR_CREATEPARTFILE));
        SetPartFileStatus(PS_ERROR);
    }
}

bool CPartFile::LoadPartFile(int type, char * in_directory, char * in_filename)
{
    // Slugfiller:
    if (type)
    {
        m_isDynamic |= 1;
        m_nHeaderLength = (m_nFileSize/ bsize + 1) * 8;
    }
    else
    {
        m_isDynamic = 0;
        m_nHeaderLength = 0;
    }
    CMap <uint16, uint16, Gap_Struct *, Gap_Struct *> gap_map;
    transfered = 0;
    partmetfilename = wxString(nstrdup(in_filename));
    directory = nstrdup(in_directory);
    char * buffer = new char[strlen(directory) + partmetfilename.Len() + 2];
    sprintf(buffer, "%s/%s", directory, partmetfilename.GetData());
    fullname = buffer;
    CFile metFile;
    if (metFile.Open(fullname, CFile::read))
        // readfile data form part.met file
        if (!file.Open(fullname, CFile:: read))
        {
        uint32 tagcount = 0;
            return false;
        }
        uint8 version = 0;
        metFile.Read( & version, 1);
        switch (version)
        {
        case PARTFILE_SPLITTEDVERSION:
        case PARTFILE_VERSION:
            isnewstyle = (version == PARTFILE_SPLITTEDVERSION);
            partmettype = isnewstyle? PMT_SPLITTED: PMT_DEFAULTOLD;
            if (!isnewstyle)
            {
printf("partfile_OLDstyle  type=%u  ",partmettype);
                uint8 test[4];
                metFile.Seek(24, wxFromStart);
                metFile.Read( & test[0], 1);
                metFile.Read( & test[1], 1);
                metFile.Read( & test[2], 1);
                metFile.Read( & test[3], 1);
                metFile.Seek(1, wxFromStart);
                if (test[0] == 0 && test[1] == 0 && test[2] == 2 && test[3] == 1)
                {
                    isnewstyle = true;
                    partmettype = PMT_NEWOLD;
        }
                LoadDateFromFile( & metFile);
                LoadHashsetFromFile( & metFile, false);
            }
            else
    */
        uint32 tagcount = 0;
        uint32 j = 0;
        try
        {
printf("partfile_NEWstyle  type=%u  ",partmettype);
                uint32 temp;
                metFile.Read( & temp, 4);
                if (temp == 0)
            {
                    LoadHashsetFromFile(&metFile, false);
                throw CInvalidPacket("short file reading tagcount");
            }
                else
            {
                    uchar gethash[16];
                    metFile.Seek(2, wxFromStart);
                    LoadDateFromFile( & metFile);
                    metFile.Read( & gethash, 16);
                    md4cpy(m_abyFileHash, gethash);
                }
            }
            if (4 == metFile.Read( & tagcount, 4))
                {
                uint32 j = 0;
                for (j = 0 ; j < tagcount ; j++)
                {
                    CTag * newtag = new CTag( & metFile);
                    switch (newtag -> tag -> specialtag)
                    {
                    case FT_FILENAME:
                        {
                            if (newtag -> tag -> stringvalue == NULL)
                            {
                                theApp.xmuledlg -> AddLogLine(true, GetResString(IDS_ERR_METCORRUPT), partmetfilename.GetData(), m_pszFileName);
                                delete newtag;
                                return false;
                            }

                            delete newtag;
                            break;
                        }
                    case FT_DYNAMIC:
                        {
                            m_isDynamic = newtag -> tag -> intvalue;
                            delete newtag;
                            break;
                        }
                    case FT_OLDDLPRIORITY:
                    case FT_DLPRIORITY:
                        {

                            (newtag -> tag -> tagname[0] == FT_GAPSTART ||
                            newtag -> tag -> tagname[0] == FT_GAPEND))
                            {
                                Gap_Struct * gap;
                                uint16 gapkey = atoi( & newtag -> tag -> tagname[1]);
                                if (!gap_map.Lookup(gapkey, gap))
                                {
                                    gap = new Gap_Struct;

                                    gap -> end = (uint32) - 1;
                                }
                                if (newtag -> tag -> tagname[0] == FT_GAPSTART)
                                {
                                gap -> start = newtag -> tag -> intvalue;
                                }
                                if (newtag -> tag -> tagname[0] == FT_GAPEND)
                                {
                                gap -> end = newtag -> tag -> intvalue - 1;
                                }
                                delete newtag;
                                // End Changes by Slugfiller for better exception handling
                            }
                            else
                            taglist.Add(newtag);
                        }
                    }
                }
                catch(CStrangePacket)
                {
                                taglist.Add(newtag);
                }
            }
        }
        catch(CInvalidPacket e)
        {
 /*
 * When failing on the last tag, this might be
 * due to a failure in xMule writing the file.
    */
            if (!tagcount || (j != tagcount - 1))
            {
                printf("failure reading part file - %s\n", e.what());
                file.Close();
                return false;
            }
        }
        file.Close();
    }
    // Now to flush the map into the list (Slugfiller)
    for (POSITION pos = gap_map.GetStartPosition() ; pos != NULL ;)
    {
                    Gap_Struct * gap;
        uint16 gapkey;
        gap_map.GetNextAssoc(pos, gapkey, gap);
                    if (gap -> start >= 0 && gap -> end >= 0 && gap -> start <= gap -> end)
                    {
        // All tags accounted for:
        gaplist.AddTail(gap);
                    }
        else
                    {
        // Some of the tags were missing:
        delete gap;
    }
                }
    //check if this is a backup
    if (strcasecmp(strrchr(fullname, '.'), ".backup") == 0)
    {
                    char * shorten = strrchr(fullname, '.');
                    * shorten = 0;
                    char * oldfullname = fullname;
        fullname = new char[strlen(fullname) + 1];
        strcpy(fullname, oldfullname);
        delete[] oldfullname;
    }
    // open permanent handle
                char * searchpath = nstrdup(fullname);
    searchpath[strlen(fullname) - 4] = 0;
                if (m_hpartfile.Open(searchpath, CFile::read_write))
    {
                    Seek(0);
        delete[] searchpath;
        return false;
    }
    delete[] searchpath;
    searchpath = NULL;
    m_SrcpartFrequency.SetSize(GetPartCount());

        hashsetneeded = false;
        for (int i = 0 ; i != hashlist.GetSize() ; i++)
        {
                            if (IsComplete(i * PARTSIZE, ((i + 1) * PARTSIZE) - 1))
            {
                SetPartFileStatus(PS_READY);
            }

        return true;
    }
    struct stat statbuf;
                    fstat(m_hpartfile.fd(), & statbuf);
    if ((time_t) date != (time_t) statbuf.st_mtime)
    {
        theApp.xmuledlg -> AddLogLine(false, GetResString(IDS_ERR_REHASH), buffer, m_pszFileName);
        // rehash
        SetPartFileStatus(PS_WAITINGFORHASH);
                        char * partfilename = nstrdup(partmetfilename.GetData());
        partfilename[strlen(partfilename) - 4] = 0;
                        CAddFileThread::AddFile(directory, partfilename, this);
        delete[] partfilename;
    }
    UpdateCompletedInfos();
    if (completedsize > transfered)
                    {
    m_iGainDueToCompression = completedsize - transfered;
                    }
    else if(completedsize != transfered)
                    {
    m_iLostDueToCorruption = transfered - completedsize;
                    }
    return true;
                }
                else
                {
                    theApp.xmuledlg -> AddLogLine(false, GetResString(IDS_ERR_FILEOPEN), fullname, m_pszFileName);
                    delete[] searchpath;
                }
            }
            else
            {
                tagcount = 0;
            }
            break;
        default:
            {
                theApp.xmuledlg -> AddLogLine(false, GetResString(IDS_ERR_BADMETVERSION),
                partmetfilename.GetData(), m_pszFileName);
            }
            break;
        }
        metFile.Close();
    }
    else
    {
        theApp.xmuledlg -> AddLogLine(false, GetResString(IDS_ERR_OPENMET), partmetfilename.GetData(),
        m_pszFileName);
    }
    return false;
}

bool CPartFile::SavePartFile(bool Initial)
{
    switch (status)
    {

    }
    /* Don't write anything to disk if less than 5000 bytes of free space is left. */
    wxLongLong total, free;
    if (wxGetDiskSpace(theApp.glob_prefs -> GetTempDir(), & total, & free) &&
    free < 5000)
    {
        return false;
    }
    FILE * file = 0;
    char * searchpath = nstrdup(fullname);
    searchpath[strlen(fullname) - 4] = 0;
    wxString fName =::wxFindFirstFile(searchpath, wxFILE);
    delete[] searchpath;
    searchpath = NULL;
    if (fName.IsEmpty())
    {
        if (file)
        fclose(file);
        theApp.xmuledlg -> AddLogLine(false, GetResString(IDS_ERR_SAVEMET),
        GetResString(IDS_ERR_PART_FNF) .GetData(), partmetfilename.GetData(), m_pszFileName);
        return false;
    }
    struct stat sbf;
    stat(fName.GetData(), & sbf);
    date = sbf.st_mtime;
    uint32 lsc = lastseencomplete;
    if (!Initial)

        throw GetResString(IDS_ERR_OPENMETFILE);
    }
    uint8 version = PARTFILE_VERSION;
    fwrite( & version, 1, 1, file);
    fwrite( & date, 4, 1, file);
    fwrite( & m_abyFileHash, 16, 1, file);
    uint16 parts = hashlist.GetCount();
    fwrite( & parts, 2, 1, file);
    for (int x = 0 ; x != parts ; x++)
    fwrite(hashlist[x], 16, 1, file);
    uint32 tagcount = taglist.GetCount() + 10 + (gaplist.GetCount() * 2);
    fwrite( & tagcount, 4, 1, file);
    CTag(FT_FILENAME, m_pszFileName) .WriteTagToFile(file);
    CTag(FT_FILESIZE, m_nFileSize) .WriteTagToFile(file);
    CTag(FT_TRANSFERED, transfered) .WriteTagToFile(file);
    CTag(FT_STATUS, (paused) ? 1: 0) .WriteTagToFile(file);
    CTag * prioritytag;
    uint8 autoprio = PR_AUTO;
    if (this -> IsAutoDownPriority())
    {

    }
    prioritytag -> WriteTagToFile(file);
    delete prioritytag;
    CTag * lsctag = new CTag(FT_LASTSEENCOMPLETE, lsc);
    lsctag -> WriteTagToFile(file);
    delete lsctag;
    CTag * ulprioritytag;
    if (this -> IsAutoUpPriority())
    {
        ulprioritytag = new CTag(FT_ULPRIORITY, autoprio);

    }
    ulprioritytag -> WriteTagToFile(file);
    delete ulprioritytag;
    CTag * categorytab = new CTag(FT_CATEGORY, m_category);
    categorytab -> WriteTagToFile(file);
    delete categorytab;
    for (uint32 j = 0 ; j != (uint32) taglist.GetCount() ; j++)
    taglist[j] -> WriteTagToFile(file);
    char * namebuffer = new char[10];
    char * number = & namebuffer[1];
    uint16 i_pos = 0;
    for (POSITION pos = gaplist.GetHeadPosition() ; pos != 0 ; gaplist.GetNext(pos))
    {
        sprintf(number, "%d", i_pos);
        namebuffer[0] = FT_GAPSTART;
        CTag * gapstarttag = new CTag(namebuffer, gaplist.GetAt(pos) -> start);
        gapstarttag -> WriteTagToFile(file);
        namebuffer[0] = FT_GAPEND;
        CTag * gapendtag = new CTag(namebuffer, (gaplist.GetAt(pos) -> end) + 1);
        gapendtag -> WriteTagToFile(file);
        delete gapstarttag;
        delete gapendtag;
        i_pos++;
    }
    delete[] namebuffer;
    if (ferror(file))
    {
        throw CString("unexpected write error");
    }
    if (!Initial)
    {
        wxRemoveFile(wxString(fullname) + ".backup");

    return true;
}

void CPartFile::PartFileHashFinished(CKnownFile * result)
{
    newdate = true;
    bool errorfound = false;
    for (uint32 i = 0 ; i != (uint32) hashlist.GetSize() ; i++)
    {
        if (IsComplete(i * PARTSIZE, ((i + 1) * PARTSIZE) - 1))
        {
            if (! (result -> GetPartHash(i) && !memcmp(result -> GetPartHash(i), this -> GetPartHash(i), 16)))
            {
                theApp.xmuledlg -> AddLogLine(false, GetResString(IDS_ERR_FOUNDCORRUPTION), i + 1, m_pszFileName);
                AddGap(i * PARTSIZE, ((((i + 1) * PARTSIZE) - 1) >= m_nFileSize) ? m_nFileSize - 1: ((i + 1) * PARTSIZE) - 1);
                errorfound = true;
            }
        }

    theApp.sharedfiles -> SafeAddKFile(this);
}

void CPartFile::AddGap(uint32 start, uint32 end)
{
    POSITION pos1, pos2;
    for (pos1 = gaplist.GetHeadPosition() ; (pos2 = pos1) != NULL ;)
    {
        Gap_Struct * cur_gap = gaplist.GetNext(pos1);
        if (cur_gap -> start >= start && cur_gap -> end <= end)
        {
            // this gap is inside the new gap - delete
            gaplist.RemoveAt(pos2);
            delete cur_gap;
            continue;
        }
        else if(cur_gap -> start >= start && cur_gap -> start <= end)
        {
            // a part of this gap is in the new gap - extend limit and delete
            end = cur_gap -> end;

            delete cur_gap;
            continue;
        }
        else if(cur_gap -> end <= end && cur_gap -> end >= start)
        {
            // a part of this gap is in the new gap - extend limit and delete
            start = cur_gap -> start;

            delete cur_gap;
            continue;
        }
        else if(start >= cur_gap -> start && end <= cur_gap -> end)
        {
            // new gap is already inside this gap - return
            return;
        }
    }
    Gap_Struct * new_gap = new Gap_Struct;
    new_gap -> start = start;
    new_gap -> end = end;
    gaplist.AddTail(new_gap);

    newdate = true;
}

bool CPartFile::IsComplete(uint32 start, uint32 end)
{
    if (end >= m_nFileSize)
    end = m_nFileSize - 1;
    for (POSITION pos = gaplist.GetHeadPosition() ; pos != 0 ; gaplist.GetNext(pos))
    {
        Gap_Struct * cur_gap = gaplist.GetAt(pos);
        if ((cur_gap -> start >= start && cur_gap -> end <= end) || (cur_gap -> start >= start
        && cur_gap -> start <= end) || (cur_gap -> end <= end && cur_gap -> end >= start)
        || (start >= cur_gap -> start && end <= cur_gap -> end))
        {
            return false;
        }

    return true;
}

bool CPartFile::IsPureGap(uint32 start, uint32 end)
{
    if (end >= m_nFileSize)
    end = m_nFileSize - 1;
    for (POSITION pos = gaplist.GetHeadPosition() ; pos != 0 ; gaplist.GetNext(pos))
    {
        Gap_Struct * cur_gap = gaplist.GetAt(pos);
        if (start >= cur_gap -> start && end <= cur_gap -> end)
        {
            return true;
        }

    return false;
}

bool CPartFile::IsAlreadyRequested(uint32 start, uint32 end)
{
    for (POSITION pos = requestedblocks_list.GetHeadPosition() ; pos != 0 ; requestedblocks_list.GetNext(pos))
    {

    return false;
}

bool CPartFile::GetNextEmptyBlockInPart(uint16 partNumber, Requested_Block_Struct * result)
{
    Gap_Struct * firstGap;
    Gap_Struct * currentGap;
    uint32 end;
    uint32 blockLimit;
    // Find start of this part
    uint32 partStart = (PARTSIZE * partNumber);
    uint32 start = partStart;
    // What is the end limit of this block, i.e. can't go outside part (or filesize)
    uint32 partEnd = (PARTSIZE * (partNumber + 1)) - 1;

    return false;
}

void CPartFile::FillGap(uint32 start, uint32 end)
{
    POSITION pos1, pos2;
    for (pos1 = gaplist.GetHeadPosition() ; (pos2 = pos1) != NULL ;)
    {
        Gap_Struct * cur_gap = gaplist.GetNext(pos1);
        if (cur_gap -> start >= start && cur_gap -> end <= end)
        {
            // our part fills this gap completly
            gaplist.RemoveAt(pos2);
            delete cur_gap;
            continue;
        }
        else if(cur_gap -> start >= start && cur_gap -> start <= end)
        {
            // a part of this gap is in the part - set limit
            cur_gap -> start = end + 1;
        }
        else if(cur_gap -> end <= end && cur_gap -> end >= start)
        {
            // a part of this gap is in the part - set limit
            cur_gap -> end = start - 1;
        }
        else if(start >= cur_gap -> start && end <= cur_gap -> end)
        {
            uint32 buffer = cur_gap -> end;
            cur_gap -> end = start - 1;

    //SavePartFile();
}

void CPartFile::UpdateCompletedInfos()
{
    uint32 allgaps = 0;
    for (POSITION pos = gaplist.GetHeadPosition() ; pos != 0 ;)
    {
        POSITION prev = pos;
        Gap_Struct * cur_gap = gaplist.GetNext(pos);
        if ((cur_gap -> end > m_nFileSize) || (cur_gap -> start >= m_nFileSize))
        gaplist.RemoveAt(prev);
        else

    }
    if (gaplist.GetCount() || requestedblocks_list.GetCount())
    {
        percentcompleted = (1.0f - (float) allgaps/ m_nFileSize) * 100;
        completedsize = m_nFileSize - allgaps - 1;
    }
    else


#include <wx/gdicmn.h>
typedef DWORD COLORREF;
void CPartFile::DrawStatusBar(wxMemoryDC * dc, wxRect rect, bool bFlat)
void CPartFile:: DrawStatusBar(wxMemoryDC *dc, wxRect rect, bool bFlat)
{
    COLORREF crProgress;
    COLORREF crHave;

    // red gaps
    for (POSITION pos = gaplist.GetHeadPosition() ; pos != 0 ; gaplist.GetNext(pos))
    {
        Gap_Struct * cur_gap = gaplist.GetAt(pos);
        allgaps += cur_gap -> end - cur_gap -> start;
        bool gapdone = false;
        uint32 gapstart = cur_gap -> start;
        uint32 gapend = cur_gap -> end;
        for (uint32 i = 0 ; i != GetPartCount() ; i++)
        {
            if (gapstart >= i * PARTSIZE && gapstart <= (i + 1) * PARTSIZE)
            {
                // is in this part?
                if (gapend <= (i + 1) * PARTSIZE)
                gapdone = true;
                else
                {
                    // and next part:
                    gapend = (i + 1) * PARTSIZE;
                }
                // paint
                COLORREF color;
                // frequency?:
                if (m_SrcpartFrequency.GetCount() >= (int) i && m_SrcpartFrequency[i])
                color = RGB(0,
                (210 - (22 * (m_SrcpartFrequency[i] - 1)) < 0) ? 0: 210 - (22 * (m_SrcpartFrequency[i] - 1))
                , 255);

    // yellow pending parts
    for (POSITION pos = requestedblocks_list.GetHeadPosition() ; pos != 0 ; requestedblocks_list.GetNext(pos))
    {
        Requested_Block_Struct * block = requestedblocks_list.GetAt(pos);
        s_ChunkBar.FillRange(block -> StartOffset, block -> EndOffset, crPending);
    }
    s_ChunkBar.Draw(dc, rect.x, rect.y, bFlat);

    gaprect.left = rect.x;
    if (!bFlat)
    {
        s_LoadBar.SetWidth((uint32)((float)((float)((m_nFileSize - ((allgaps == 0) ? 1: allgaps)) - 1)) * blockpixel + .5f));
        s_LoadBar.Fill(crProgress);
        s_LoadBar.Draw(dc, gaprect.left, gaprect.top, false);
    }
    else
    {
        gaprect.right = rect.x + (uint32)((float)((float)((m_nFileSize - ((allgaps == 0) ? 1: allgaps)) - 1)) * blockpixel + .5f);
        //wxBrush(crProgress));:
        dc -> SetBrush( * (wxTheBrushList -> FindOrCreateBrush(wxColour(crProgress), wxSOLID)));
        dc -> DrawRectangle(gaprect.left, gaprect.top, gaprect.right, gaprect.bottom);

    }
    if ((gaplist.GetCount() || requestedblocks_list.GetCount()))
    {
        percentcompleted = ((1.0f - (float) allgaps/ m_nFileSize)) * 100;
        completedsize = m_nFileSize - allgaps - 1;
    }
    else

    }
}

void CPartFile::WritePartStatus(CMemFile * file)
{
    uint16 parts = hashlist.GetCount();
    file -> Write( & parts, 2);
    uint16 done = 0;
    while (done != parts)
    {
        uint8 towrite = 0;
        for (uint32 i = 0 ; i != 8 ; i++)
        {
            if (IsComplete(done * PARTSIZE, ((done + 1) * PARTSIZE) - 1))
            towrite |= (1 << i);
            done++;
            if (done == parts)
            break;
        }
        file -> Write( & towrite, 1);
    }
}

int CPartFile::GetValidSourcesCount()
{
    int counter = 0;
    POSITION pos1, pos2;

    for (pos1 = srclists[sl].GetHeadPosition() ; (pos2 = pos1) != NULL ;)
    {
        srclists[sl].GetNext(pos1);
        CUpDownClient * cur_src = srclists[sl].GetAt(pos2);
        if (cur_src -> GetDownloadState() != DS_ONQUEUE && cur_src -> GetDownloadState() != DS_DOWNLOADING &&
        cur_src -> GetDownloadState() != DS_NONEEDEDPARTS) counter++;
    }
    return counter;
}

uint16 CPartFile::GetNotCurrentSourcesCount()
{
    uint16 counter = 0;
    POSITION pos1, pos2;

    for (pos1 = srclists[sl].GetHeadPosition() ; (pos2 = pos1) != NULL ;)
    {
        srclists[sl].GetNext(pos1);
        CUpDownClient * cur_src = srclists[sl].GetAt(pos2);
        if (cur_src -> GetDownloadState() != DS_ONQUEUE && cur_src -> GetDownloadState() != DS_DOWNLOADING) counter++;
    }
    return counter;
}

uint8 CPartFile::GetStatus(bool ignorepause)
{
    if ((!paused) || status == PS_ERROR || ignorepause)
    return status;

    return PS_PAUSED;
}

uint32 CPartFile::Process(uint32 reducedownload)
{
    //in percent
    uint16 old_trans;
    DWORD dwCurTick =::GetTickCount();
    // If buffer size exceeds limit, or if not written within time limit, flush data
    if ((m_nTotalBufferData > theApp.glob_prefs -> GetFileBufferSize()))
    {

    // check if we want new sources from server
    //uint16 test = theApp.glob_prefs->GetMaxSourcePerFileSoft();
    if (((!lastsearchtime) || (dwCurTick - lastsearchtime) > SERVERREASKTIME)
    && theApp.serverconnect -> IsConnected()
    && theApp.glob_prefs -> GetMaxSourcePerFileSoft() > GetSourceCount() && !stopped)
    {
        //local server
        lastsearchtime = dwCurTick;
        Packet * packet = new Packet(OP_GETSOURCES, 16);
        memcpy(packet -> pBuffer, m_abyFileHash, 16);
        theApp.uploadqueue -> AddUpDataOverheadServer(packet -> size);
        theApp.serverconnect -> SendPacket(packet, true);

            for (pos1 = srclists[sl].GetHeadPosition() ; (pos2 = pos1) != NULL ;)
            {
                srclists[sl].GetNext(pos1);
                CUpDownClient * cur_src = srclists[sl].GetAt(pos2);
                switch (cur_src -> GetDownloadState())
                {
                case DS_DOWNLOADING:

                        transferingsrc++;
                        uint32 cur_datarate = cur_src -> CalculateDownloadRate();
                        datarate += cur_datarate;
                        if (reducedownload && cur_src -> GetDownloadState() == DS_DOWNLOADING)
                        {
                            //(uint32)(((float)reducedownload/100)*cur_datarate)/10;:
                            uint32 limit = reducedownload * cur_datarate/ 1000;
                            if (limit < 1000 && reducedownload == 200)
                            limit += 1000;
                            else if(limit < 1)
                            limit = 1;

                            break;
                        }
                        // doubled reasktime for no needed parts - save connections and traffic
                        if (! ((!cur_src -> GetLastAskedTime()) || (dwCurTick - cur_src -> GetLastAskedTime()) > FILEREASKTIME * 2))
                        break;
                    }
                case DS_ONQUEUE:

                            //Johnny-B - nothing more to do here (good eye!):
                            break;
                        }
                        if (((!cur_src -> GetLastAskedTime()) || (dwCurTick - cur_src -> GetLastAskedTime()) > FILEREASKTIME - 20000)) {
                        cur_src -> UDPReaskForDownload();
                    }
                    }
                case DS_CONNECTED:
                case DS_CONNECTING:
                    if ((dwCurTick - cur_src -> GetLastAskedTime()) > FILEREASKTIME)

            for (pos1 = this -> A4AFSourcesList.GetHeadPosition() ; (pos2 = pos1) != NULL ;)
            {
                this -> A4AFSourcesList.GetNext(pos1);
                CUpDownClient * cur_source = this -> A4AFSourcesList.GetAt(pos2);
                if (! (cur_source -> GetDownloadState() == DS_DOWNLOADING))
                {
                    this -> A4AFSourcesList.RemoveAt(pos2);

        }
    }
    /* Sources droping engine. Auto drop allowed type of sources at interval. */
    if ((dwCurTick - m_LastSourceDropTime) > theApp.glob_prefs -> GetAutoDropTimer() * 1000)
    {
        m_LastSourceDropTime = dwCurTick;
    /* If all three are enabled, use CleanUpSources() function, will save us some CPU. */
        if (theApp.glob_prefs -> DropNoNeededSources() && theApp.glob_prefs -> DropFullQueueSources() && theApp.glob_prefs -> DropHighQueueRankingSources())
        {
            CleanUpSources();
        }

    return datarate;
}

void CPartFile::AddSources(CMemFile * sources, uint32 serverip, uint16 serverport)
{
    if (stopped) return;
    uint8 count;
    uint8 debug_lowiddropped = 0;
    uint8 debug_possiblesources = 0;
    sources -> Read( & count, 1);
    for (int i = 0 ; i != count ; i++)
    {
        uint32 userid;
        sources -> Read( & userid, 4);
        uint16 port;
        sources -> Read( & port, 2);
        // check first if we are this source
        // MOD Note: Do not change this part - Merkur
        if (theApp.serverconnect -> GetClientID() < 16777216 && theApp.serverconnect -> IsConnected())
        {
            if ((theApp.serverconnect -> GetClientID() == userid) && inet_addr(theApp.serverconnect -> GetCurrentServer() -> GetFullIP()) == serverip) {
            continue;
        }
        }
        else if(theApp.serverconnect -> GetClientID() == userid)
	{
        continue;
	}
        else if(userid < 16777216 && !theApp.serverconnect -> IsLocalServer(serverip, serverport))
        {
            debug_lowiddropped++;

        if (theApp.glob_prefs -> GetMaxSourcePerFile() > this -> GetSourceCount())
        {
            debug_possiblesources++;
            CUpDownClient * newsource = new CUpDownClient(port, userid, serverip, serverport, this);
            theApp.downloadqueue -> CheckAndAddSource(this, newsource);
        }
    }
    theApp.xmuledlg -> AddDebugLogLine(false, "RCV: %i sources from server, %i low id dropped, %i possible sources File(%s)", count, debug_lowiddropped, debug_possiblesources, GetFileName());
}

void CPartFile::NewSrcPartsInfo()
{
    // Cache part count
    uint16 partcount = GetPartCount();

    {
        m_SrcpartFrequency[i] = 0;
    }
    CUpDownClient * cur_src;
    for (int sl = 0 ; sl < SOURCESSLOTS ;++sl)
    {
        if (!srclists[sl].IsEmpty())

    UpdateDisplayedInfo();
}

bool CPartFile::GetNextRequestedBlock(CUpDownClient * sender, Requested_Block_Struct ** newblocks, uint16 * count)
{
    uint16 requestedCount = * count;
    uint16 newblockcount = 0;
    uint8 * partsav = sender -> GetPartStatus();
    * count = 0;
    uint16 randomness;
    CList <int, int > liGoodParts;
    CList <int, int > liPossibleParts;
    bool finished = false;
    while (!finished)
    {
        // Need to empty lists to avoid infinite loop when file is smaller than 180k
        // Otherwise it would keep looping to find 3 blocks, there is only one and it is requested
        liGoodParts.RemoveAll();
        liPossibleParts.RemoveAll();
        // Barry - Top priority should be to continue downloading from current blocks (if anything left to download)

            }
        }
        // Barry - Give priorty to end parts of archives and movies
        if ((!foundPriorityPart) && (IsArchive() || IsMovie()) && theApp.glob_prefs -> GetPreviewPrio())
        {
            uint32 partCount = GetPartCount();
            // First part
            if (sender -> IsPartAvailable(0) && GetNextEmptyBlockInPart(0, 0))
            {
                liGoodParts.AddHead(0);
                foundPriorityPart = true;

            else if((partCount > 1))
            {
                // Last part
                if (sender -> IsPartAvailable(partCount - 1) && GetNextEmptyBlockInPart(partCount - 1, 0))
                {
                    liGoodParts.AddHead(partCount - 1);
                    foundPriorityPart = true;

                else if(partCount > 2)
                {
                    // Second part
                    if (sender -> IsPartAvailable(1) && GetNextEmptyBlockInPart(1, 0))
                    liGoodParts.AddHead(1);
                    // Penultimate part
                    else if(sender -> IsPartAvailable(partCount - 2) && GetNextEmptyBlockInPart(partCount - 2, 0))
                    liGoodParts.AddHead(partCount - 2);
                }
            }
        }
        if (!foundPriorityPart)
        {
            randomness = (uint16) ROUND(((float) rand() / RAND_MAX) * (GetPartCount() - 1));
            for (uint16 i = 0 ; i != GetPartCount() ; i++)
            {
                if (sender -> IsPartAvailable(randomness))
                {
                    if (partsav[randomness] && !IsComplete(randomness * PARTSIZE, ((randomness + 1) * PARTSIZE) - 1))
                    {
 /*if (IsCorruptedPart(randomness)){
 if (GetNextEmptyBlockInPart(randomness,0)){

 }
 }
    else */
                        if (IsPureGap(randomness * PARTSIZE, ((randomness + 1) * PARTSIZE) - 1))
                        {
                            if (GetNextEmptyBlockInPart(randomness, 0))
                            liPossibleParts.AddHead(randomness);

                randomness = 0;
            }
        }
        CList <int, int > * usedlist;
        if (!liGoodParts.IsEmpty())
        usedlist = & liGoodParts;
        else if(!liPossibleParts.IsEmpty())
        usedlist = & liPossibleParts;
        else
        {
            if (!newblockcount)

        for (POSITION pos = usedlist -> GetHeadPosition() ; pos != 0 ; usedlist -> GetNext(pos))
        {
            if (m_SrcpartFrequency.GetCount() >= usedlist -> GetAt(pos)
            && m_SrcpartFrequency[usedlist -> GetAt(pos) ] < nRarest)
            {
                nRarest = m_SrcpartFrequency[usedlist -> GetAt(pos) ];
                usedpart = usedlist -> GetAt(pos);

        }
        while (true)
        {
            Requested_Block_Struct * block = new Requested_Block_Struct;
            if (GetNextEmptyBlockInPart(usedpart, block))
            {
                requestedblocks_list.AddTail(block);

        }
        //wend:
    }
    * count = newblockcount;
    return true;
}

void CPartFile::RemoveBlockFromList(uint32 start, uint32 end)
{
    POSITION pos1, pos2;
    for (pos1 = requestedblocks_list.GetHeadPosition() ; (pos2 = pos1) != NULL ;)
    {
        requestedblocks_list.GetNext(pos1);
        if (requestedblocks_list.GetAt(pos2) -> StartOffset <= start && requestedblocks_list.GetAt(pos2) -> EndOffset >= end)
        requestedblocks_list.RemoveAt(pos2);
    }
}

void CPartFile::RemoveAllRequestedBlocks(void)
{
    requestedblocks_list.RemoveAll();
}

#include <pthread.h>
pthread_attr_t pattr;
void CPartFile::CompleteFile(bool bIsHashingDone)
void CPartFile:: CompleteFile(bool bIsHashingDone)
{
    if (this -> srcarevisible)
    {
    theApp.xmuledlg -> transferwnd -> downloadlistctrl -> HideSources(this);
    }
    SetPartFileStatus(PS_COMPLETING);
    if (!bIsHashingDone)
    {
        datarate = 0;
        char * partfileb = nstrdup(partmetfilename.GetData());
        partfileb[partmetfilename.Len() - 4] = 0;
        CAddFileThread::AddFile(theApp.glob_prefs -> GetTempDir(), partfileb, this);
        delete[] partfileb;
        return;
    }
    else
    {
        StopFile(0);
        // guess I was wrong about not need to spaw a thread.. It is if the temp and incoming dirs are on different partitions/drives and the file is large...[oz]
        // use pthreads
        pthread_t tid;
        pthread_attr_init( & pattr);
        pthread_attr_setdetachstate( & pattr, PTHREAD_CREATE_DETACHED);
        pthread_create( & tid, & pattr, (void * ( *)(void *)) CompleteThreadProc, this);
    }
    theApp.xmuledlg -> transferwnd -> downloadlistctrl -> ShowFilesCount();
    UpdateDisplayedInfo(true);
    }
}

UINT CPartFile::CompleteThreadProc(CPartFile * pFile)
{
    if (!pFile)
    {
    return(UINT) - 1;
    }
    pFile -> PerformFileComplete();
    return 0;
}

// Lord KiRon - using threads for file completion
BOOL CPartFile::PerformFileComplete()
{
    //CSingleLock(&m_FileCompleteMutex,TRUE); // will be unlocked on exit
    wxMutexLocker sLock(m_FileCompleteMutex);
    char * partfilename = nstrdup(fullname);
    // assumes ".met" at the end:
    partfilename[strlen(fullname) - 4] = 0;
    char * newfilename = nstrdup(GetFileName());
    strcpy(newfilename, theApp.StripInvalidFilenameChars(newfilename));
    char * newname = new char[strlen(newfilename) + strlen(theApp.glob_prefs -> GetCategory(GetCategory()) -> incomingpath) + MAX_PATH * 2];
    wxString indir;
    if (wxFileName::DirExists(theApp.glob_prefs -> GetCategory(GetCategory()) -> incomingpath))
    if (wxFileName:: DirExists(theApp.glob_prefs -> GetCategory(GetCategory()) -> incomingpath))
    {
        indir = theApp.glob_prefs -> GetCategory(GetCategory()) -> incomingpath;
        sprintf(newname, "%s/%s", indir.GetData(), newfilename);

        indir = theApp.glob_prefs -> GetIncomingDir();
        sprintf(newname, "%s/%s", indir.GetData(), newfilename);
    }
    // add this file to the suspended uploads list
    CFileHash tmp_filehash(GetFileHash());
    theApp.uploadqueue -> SuspendUpload(tmp_filehash);
    FlushBuffer();
    // close permanent handle
    m_hpartfile.Close();
    bool renamed = false;
    if (wxFileName::FileExists(newname))
    {
        renamed = true;
        int namecount = 0;
        size_t length = strlen(newfilename);
        char * ext = strrchr(newfilename, '.');
        char *ext = strrchr(newfilename, '.');
        if (ext == NULL)
        {
        ext = newfilename + length;
        }
        char * last = ext;
        //truncate file name:
        last[0] = 0;
        //serch for matching ()s and check if it contains a number
        if ((ext != newfilename) && (strrchr(newfilename, ')') + 1 == last))
        {
            char * first = strrchr(newfilename, '(');
            if (first != NULL)
            {
                first++;
                bool found = true;
                for (char * step = first ; step < last - 1 ; step++)
                if (step[0] < '0' || step[0] > '9')
                {
                    found = false;
                    break;

                {
                    namecount = atoi(first);
                    last = first - 1;
                    //truncate again:
                    last[0] = 0;
                }
            }
        }
        wxString strTestName;
        do
        {
            namecount++;
            strTestName.Format("%s/%s(%d).%s", theApp.glob_prefs -> GetIncomingDir(),
            newfilename, namecount, min(ext + 1, newfilename + length));
        }
        while (wxFileName::FileExists(strTestName));
        delete[] newname;
        newname = nstrdup(strTestName);
    }
    delete[] newfilename;
    if (IsDynamic() > 1)
    {
        if (!Store(newname))
        {
            return false;
        }
        FlushBuffer();
        Close();
    }
    else
    {
        FlushBuffer();
        Close();
    if (!wxRenameFile(partfilename, newname))
    {
        if (!SafeCopyFile(partfilename, newname))

            printf("info: could not remove original '%s' after creating backup\n", partfilename);
        }
    }
    }
    if (!wxRemoveFile(fullname))
    {
        wxMutexGuiEnter();
        theApp.xmuledlg -> AddLogLine(true, GetResString(IDS_ERR_DELETEFAILED), fullname);
        wxMutexGuiLeave();
    }
    wxString BAKName(fullname);
    BAKName.Append(".BAK");
    if (!wxRemoveFile(BAKName))
    {

        theApp.xmuledlg -> AddLogLine(true, GetResString(IDS_DOWNLOADRENAMED), (strrchr(newname, '/') ? strrchr(newname, '/') + 1: newname));
        wxMutexGuiLeave();
    }
    // TODO: What the f*** if it is already known?
    theApp.knownfiles -> SafeAddKFile(this);
    // remove the file from the suspended uploads list
    theApp.uploadqueue -> ResumeUpload(tmp_filehash);
    SetAutoUpPriority(false);
    theApp.downloadqueue -> RemoveFile(this);
    //theApp.xmuledlg->transferwnd.downloadlistctrl.UpdateItem(this);
    wxMutexGuiEnter();
    UpdateDisplayedInfo();
    theApp.xmuledlg -> transferwnd -> downloadlistctrl -> ShowFilesCount();
    wxMutexGuiLeave();
    //SHAddToRecentDocs(SHARD_PATH, fullname); // This is a real nasty call that takes ~110 ms on my 1.4 GHz Athlon and isn't really needed afai see...[ozon]
    // Barry - Just in case
    //		transfered = m_nFileSize;
    wxMutexGuiEnter();
    theApp.downloadqueue -> StartNextFile();
    wxMutexGuiLeave();
    return TRUE;
}

void CPartFile::RemoveAllSources(int fx, bool bTryToSwap)
{
    CUpDownClient * client;
    POSITION pos1, pos2;
    for (int sl = 0 ; sl < SOURCESSLOTS ; sl++)
    {
        if (!srclists[sl].IsEmpty())
        {
    for (pos1 = srclists[sl].GetHeadPosition() ; (pos2 = pos1) != NULL ;)
    {
        srclists[sl].GetNext(pos1);
        if (bTryToSwap)
        {
                    client = srclists[sl].GetAt(pos2);
                    if (fx)
                    {
                        if (client -> GetDownloadState() != DS_DOWNLOADING)
                        {
                            (void) client -> SwapToAnotherFile();
                        }
        }
        else
                    {
                        if (!client -> SwapToAnotherFile())
                        {
                            theApp.downloadqueue -> RemoveSource(client);
                        }
                    }
                }
                else
                {
                    if (!fx)
                    {
                        theApp.downloadqueue -> RemoveSource(client);
                    }
                }
            }
        }
    }
    if (!fx)
    {
    /* Razor 1a - Modif by MikaelB */
    if (!this -> A4AFSourcesList.IsEmpty())
    {

        }
    }
    /* End modif */
    }
    UpdateFileRatingCommentAvail();
}

void CPartFile::DeleteFile()
{
    StopFile(0);
    StopFile();
    theApp.sharedfiles -> RemoveFile(this);
    theApp.downloadqueue -> RemoveFile(this);
    theApp.xmuledlg -> transferwnd -> downloadlistctrl -> RemoveFile(this);
    Close();
    if (!wxRemoveFile(fullname))
    theApp.xmuledlg -> AddLogLine(true, GetResString(IDS_ERR_DELETE), fullname);
    char * partfilename = nstrdup(fullname);
    partfilename[strlen(fullname) - 4] = 0;
    if (!wxRemoveFile(partfilename))
    theApp.xmuledlg -> AddLogLine(true, GetResString(IDS_ERR_DELETE), partfilename);
    wxString BAKName(fullname);
    BAKName.Append(".BAK");
    if (!wxRemoveFile(BAKName))
    theApp.xmuledlg -> AddLogLine(true, GetResString(IDS_ERR_DELETE), BAKName.GetData());
    delete[] partfilename;
}

void CPartFile::CreateHash(wxUint32 Length, unsigned char * Output)
{
    bool PaddingStarted = false;
    wxUint32 Hash[4];
    Hash[0] = 0x67452301;
    Hash[1] = 0xEFCDAB89;
    Hash[2] = 0x98BADCFE;
    Hash[3] = 0x10325476;
    wxUint32 Required = Length;
    unsigned char X[64 * 128];
    while (Required >= 64)
    {
        wxUint32 len = Required / 64;
        if (len > sizeof(X) / (64 * sizeof(X[0])))
        {
            len = sizeof(X) / (64 * sizeof(X[0]));
        }
        Read( & X, len * 64);
        for (wxUint32 i = 0 ; i < len ; i++)
        {
            MD4Transform(Hash, (wxUint32 *)(X + i * 64));
        }
        Required -= len * 64;
    }
    // bytes to read
    Required = Length % 64;
    if (Required)
    {
        Read( & X, Required);
    }
    // in byte scale 512 = 64, 448 = 56
    if (Required >= 56)
    {
        X[Required] = 0x80;
        PaddingStarted = TRUE;
        memset( & X[Required + 1], 0, 63 - Required);
        MD4Transform(Hash, (wxUint32 *) X);
        Required = 0;
    }
    if (!PaddingStarted)
    {
        X[Required++] = 0x80;
    }
    memset( & X[Required], 0, 64 - Required);
    // add size (convert to bits)
    wxUint32 Length2 = Length >> 29;
    Length <<= 3;
    memcpy( & X[56], & Length, 4);
    memcpy( & X[60], & Length2, 4);
    MD4Transform(Hash, (wxUint32 *) X);
    memcpy(Output, Hash, 16);
}

bool CPartFile::HashSinglePart(uint16 partnumber)
{
    bool retcode = true;
    if ((GetHashCount() <= partnumber) && (GetPartCount() > 1))
    {
        theApp.xmuledlg -> AddLogLine(true, GetResString(IDS_ERR_HASHERRORWARNING), GetFileName());
        this -> hashsetneeded = true;
        return true;
    }
    else if(!GetPartHash(partnumber) && GetPartCount() != 1)
    {
        theApp.xmuledlg -> AddLogLine(true, GetResString(IDS_ERR_INCOMPLETEHASH), GetFileName());
        this -> hashsetneeded = true;
        return true;
    }
    else
    {
        unsigned char hashresult[16];
        Seek(PARTSIZE * partnumber);
        uint32 length = PARTSIZE;
        if (PARTSIZE * (partnumber + 1) > m_nFileSize)
        {
            length = (m_nFileSize - (PARTSIZE * partnumber));
        }
        CreateHash(length, hashresult);
        if (GetPartCount() > 1)
        {
            if (memcmp(hashresult, GetPartHash(partnumber), 16))
            {
                retcode = false;
            return true;
        }
        }
        else if(memcmp(hashresult, m_abyFileHash, 16))
        {
            retcode = false;
            return false;
            else
            return true;
        }
    }
    return retcode;
}

bool CPartFile::IsCorruptedPart(uint16 partnumber)
{
    return corrupted_list.Find(partnumber);
}

bool CPartFile::IsMovie()
{
    bool it_is;
    wxString extension = wxString(GetFileName()) .Right(5);

    return(it_is);
}

bool CPartFile::IsArchive()
{
    bool it_is;
    wxString extension = wxString(GetFileName()) .Right(4);

    return(it_is);
}

bool CPartFile::IsSound()
{
    bool it_is;
    wxString extension = wxString(GetFileName()) .Right(4);

    return(it_is);
}

bool CPartFile::IsCDImage()
{
    bool it_is;
    wxString extension = wxString(GetFileName()) .Right(4);

    return(it_is);
}

bool CPartFile::IsImage()
{
    bool it_is;
    wxString extension = wxString(GetFileName()) .Right(5);

    return(it_is);
}

bool CPartFile::IsText()
{
    bool it_is;
    wxString extension = wxString(GetFileName()) .Right(5);

    return(it_is);
}

void CPartFile::SetDownPriority(uint8 np)
{
    m_iDownPriority = np;
    theApp.downloadqueue -> SortByPriority();

    SavePartFile();
}

void CPartFile::StopFile(int fx)
{
    // Barry - Need to tell any connected clients to stop sending the file
    // Kry - Need to set it hereto get into SetPartFileStatus(status) correctly:
    stopped = true;
    PauseFile();
    RemoveAllSources(0, true);
    datarate = 0;
    transferingsrc = 0;
    FlushBuffer();

    UpdateDisplayedInfo(true);
}

void CPartFile::PauseFile()
{
    if (status == PS_COMPLETE || status == PS_COMPLETING) return;
    Packet * packet = new Packet(OP_CANCELTRANSFER, 0);
    POSITION pos1, pos2;
    for (int sl = 0 ; sl < SOURCESSLOTS ; sl++)
    {

            for (pos1 = srclists[sl].GetHeadPosition() ; (pos2 = pos1) != NULL ;)
            {
                srclists[sl].GetNext(pos1);
                CUpDownClient * cur_src = srclists[sl].GetAt(pos2);
                if (cur_src -> GetDownloadState() == DS_DOWNLOADING)
                {
                    theApp.uploadqueue -> AddUpDataOverheadOther(packet -> size);
#if defined(__DEBUG__)
                    // printf("CPartFile::PauseFile OP_CANCELTRANSFER size\n", packet -> size);
#endif
                    cur_src -> socket -> SendPacket(packet, false, true);
                    cur_src -> SetDownloadState(DS_ONQUEUE);
                }

    SavePartFile();
}

void CPartFile::ResumeFile()
{
    if (status == PS_COMPLETE || status == PS_COMPLETING) return;
    paused = false;

    UpdateDisplayedInfo(true);
}

wxString CPartFile::getPartfileStatus()
{
    wxString mybuffer = "";
    if (GetTransferingSrcCount() > 0) mybuffer = GetResString(IDS_DOWNLOADING);
    else mybuffer = GetResString(IDS_WAITING);
    switch (GetStatus())

    case PS_COMPLETE:
        mybuffer = GetResString(IDS_COMPLETE);
        break;
    case PS_CONVERTING:
        mybuffer = GetResString(IDS_CONVERTING);
        break;
    case PS_PAUSED:
        mybuffer = GetResString(IDS_PAUSED);
        break;

    return mybuffer;
}

int CPartFile::getPartfileStatusRang()
{
    int tempstatus = 0;
    if (GetTransferingSrcCount() == 0) tempstatus = 1;

    return tempstatus;
}

sint32 CPartFile::getTimeRemaining()
{
    if (GetDatarate() == 0) return - 1;
    return((GetFileSize() - GetCompletedSize()) / GetDatarate());
}

void CPartFile::PreviewFile()
{
    wxString command;
    // If no player set in preferences, use mplayer.
    if (theApp.glob_prefs -> GetVideoPlayer() =="")
    command.Append(wxT("mplayer"));
    else
    command.Append(theApp.glob_prefs -> GetVideoPlayer());

    wxShell(command.c_str());
}

bool CPartFile::PreviewAvailable()
{
    return(IsMovie() && IsComplete(0, PARTSIZE));
}

void CPartFile::UpdateAvailablePartsCount()
{
    uint8 availablecounter = 0;
    bool breakflag = false;

            }
        }
    }
    if (iPartCount == availablecounter && availablePartsCount < iPartCount)
    //CTime::GetCurrentTime();:
    lastseencomplete = time(NULL);
    availablePartsCount = availablecounter;
}

Packet * CPartFile::CreateSrcInfoPacket(CUpDownClient * forClient)
{
#if defined(__DEBUG__)
    // printf("CPartFile:: CreateSrcInfoPacket\n");
#endif
    int sl;
    for (sl = 0 ; sl < SOURCESSLOTS ; sl++) if(srclists[sl].IsEmpty()) return 0;
    CMemFile data;
    uint16 nCount = 0;
    data.Write(m_abyFileHash, 16);
    data.Write( & nCount, 2);
    bool bNeeded;
    for (sl = 0 ; sl < SOURCESSLOTS ; sl++) if(!srclists[sl].IsEmpty())
    for (POSITION pos = srclists[sl].GetHeadPosition() ; pos != 0 ; srclists[sl].GetNext(pos))
    {
        bNeeded = false;
        CUpDownClient * cur_src = srclists[sl].GetAt(pos);
        if (cur_src -> HasLowID())
        continue;
        // only send source which have needed parts for this client if possible
        uint8 * srcstatus = cur_src -> GetPartStatus();
        if (srcstatus)
        {
            uint8 * reqstatus = forClient -> GetPartStatus();
            if (reqstatus)
            {
                // only send sources which have needed parts for this client

            uint16 nPort = cur_src -> GetUserPort();
            uint32 dwServerIP = cur_src -> GetServerIP();
            uint16 nServerPort = cur_src -> GetServerPort();
            data.Write( & dwID, 4);
            data.Write( & nPort, 2);
            data.Write( & dwServerIP, 4);
            data.Write( & nServerPort, 2);
            if (forClient -> GetSourceExchangeVersion() > 1)
            data.Write(cur_src -> GetUserHash(), 16);
            if (nCount > 500)
            break;
        }
    }
    if (nCount)
    {
    data.Seek(16);
        data.Write( & nCount, 2);
        Packet * result = new Packet( & data, OP_EMULEPROT);
    result -> opcode = OP_ANSWERSOURCES;
    if (nCount > 28)
        {
    result -> PackPacket();
        }
    theApp.xmuledlg -> AddDebugLogLine(false, "Send:Source User(%s) File(%s) Count(%i)", forClient -> GetUserName(), GetFileName(), nCount);
    return result;
    }
    else
    {
        return 0;
    }
}

void CPartFile::AddClientSources(CMemFile * sources, uint8 sourceexchangeversion)
{
    if (stopped) return;
    uint16 nCount;
    sources -> Read( & nCount, 2);
    for (int i = 0 ; i != nCount ; i++)
    {
        uint32 dwID;

        uint32 dwServerIP;
        uint16 nServerPort;
        uchar achUserHash[16];
        sources -> Read( & dwID, 4);
        sources -> Read( & nPort, 2);
        sources -> Read( & dwServerIP, 4);
        sources -> Read( & nServerPort, 2);
        if (sourceexchangeversion > 1)
        {
        sources -> Read(achUserHash, 16);
        }
        // check first if we are this source
        if (theApp.serverconnect -> GetClientID() < 16777216 && theApp.serverconnect -> IsConnected())
        {
            if ((theApp.serverconnect -> GetClientID() == dwID) && theApp.serverconnect -> GetCurrentServer() -> GetIP() == dwServerIP)
            continue;
        }
        else if(theApp.serverconnect -> GetClientID() == dwID)
        {
        continue;
        }
        else if(dwID < 16777216)
        {
        continue;
        }
        if (theApp.glob_prefs -> GetMaxSourcePerFile() > this -> GetSourceCount())
        {
            CUpDownClient * newsource = new CUpDownClient(nPort, dwID, dwServerIP, nServerPort, this);
            if (sourceexchangeversion > 1)
            {
            newsource -> SetUserHash(achUserHash);
            }
            theApp.downloadqueue -> CheckAndAddSource(this, newsource);
        }
        else
        {
		i=nCount;
	} 
    }
}

void CPartFile::UpdateAutoDownPriority()
{
    if (!IsAutoDownPriority())
    return;


// making this function return a higher when more sources have the extended
// protocol will force you to ask a larger variety of people for sources
int CPartFile::GetCommonFilePenalty()
{
    //TODO: implement, but never return less than MINCOMMONPENALTY!
    return MINCOMMONPENALTY;

 fill a gap.
    */

uint32 CPartFile::WriteToBuffer(uint32 transize, BYTE * data, uint32 start, uint32 end, Requested_Block_Struct * block)
{
    // Increment transfered bytes counter for this file
    transfered += transize;
    // This is needed a few times
    uint32 lenData = end - start + 1;
    if (lenData > transize)
    {
    m_iGainDueToCompression += lenData - transize;
    }
    if (IsComplete(start, end))
    {
        theApp.xmuledlg -> AddDebugLogLine(false, "File '%s' has already been written from %ld to %ld\n", GetFileName(), start, end);
        return 0;
    }
    BYTE * buffer = new BYTE[lenData];
    BYTE *buffer = new BYTE[lenData];
    memcpy(buffer, data, lenData);
    PartFileBufferedData * item = new PartFileBufferedData;
    PartFileBufferedData *item = new PartFileBufferedData;
    item -> data = buffer;
    item -> start = start;
    item -> end = end;
    item -> block = block;
    PartFileBufferedData * queueItem;
    PartFileBufferedData *queueItem;
    bool added = false;
    POSITION pos = m_BufferedData_list.GetTailPosition();
    while (pos != NULL)

        }
    }
    if (!added)
    {
    m_BufferedData_list.AddHead(item);
    }
    m_nTotalBufferData += lenData;
    // Mark this small section of the file as filled
    FillGap(item -> start, item -> end);
    // Update the flushed mark on the requested block
    // The loop here is unfortunate but necessary to detect deleted blocks.
    pos = requestedblocks_list.GetHeadPosition();
    while (pos != NULL)
    {
        if (requestedblocks_list.GetNext(pos) == item -> block)
        {
        item -> block -> transferred += lenData;
    }
    }
    if (gaplist.IsEmpty())
    {
        FlushBuffer();
    }
    return lenData;
}

void CPartFile::FlushBuffer(void)
{
    m_nLastBufferFlushTime = GetTickCount();
    if (!m_BufferedData_list.IsEmpty())
    {
        int i;
    }
 /* Madcat - Check if there is at least PARTSIZE amount of free disk space
 in temp dir before flushing. If not enough space, pause the file,
    add log line and abort flushing. */
    wxLongLong total, free;
        if (wxGetDiskSpace(theApp.glob_prefs -> GetTempDir(), & total, & free) &&
    free < PARTSIZE)
    {
        theApp.xmuledlg -> AddLogLine(true, GetResString(IDS_OUT_OF_SPACE));

        return;
    }
    uint32 partCount = GetPartCount();
        bool * changedPart = new bool[partCount];
    try
    {
        // Remember which parts need to be checked at the end of the flush
        for (int partNumber = 0 ; (uint32) partNumber < partCount ; partNumber++)
        {
            changedPart[partNumber] = false;
        }
        // Ensure file is big enough to write data to (the last item will be the furthest from the start)
        PartFileBufferedData * item = m_BufferedData_list.GetTail();
        if (m_hpartfile.Length() <= item -> end)
        //m_hpartfile.SetLength(item->end + 1);
        ftruncate(m_hpartfile.fd(), item -> end + 1);
        // Loop through queue
        i = m_BufferedData_list.GetCount();
        while (i > 0)
        {
            if (i < 1)
            {
                // Can this happen ?
                // Well, if it did... abort then.:
                return;
            }
            // Get top item
            item = m_BufferedData_list.GetHead();
            // This is needed a few times
            uint32 lenData = item -> end - item -> start + 1;
            int curpart = item -> start/ PARTSIZE;
            changedPart[curpart] = true;
            Seek(item -> start);
            Write(item -> data, lenData);
            m_hpartfile.Write(item -> data, lenData);
            // Remove item from queue
            m_BufferedData_list.RemoveHead();
            // Decrease buffer size
            m_nTotalBufferData -= lenData;
            // Release memory used by this item
            delete [] item -> data;
            delete item;
            i--;
        }
        // Flush to disk
        m_hpartfile.Flush();

                continue;
            }
            // Is this 9MB part complete
            if (IsComplete(PARTSIZE * partNumber, (PARTSIZE * (partNumber + 1)) - 1))
            {
                // Is part corrupt
                if (!HashSinglePart(partNumber))
                {
                    theApp.xmuledlg -> AddLogLine(true, GetResString(IDS_ERR_PARTCORRUPT), partNumber, GetFileName());
                    AddGap(PARTSIZE * partNumber, (PARTSIZE * partNumber + partRange));
                    corrupted_list.AddTail(partNumber);
                    // Reduce transfered amount by corrupt amount
                    this -> m_iLostDueToCorruption += (partRange + 1);

                    }
                }
            }
            else if(IsCorruptedPart(partNumber) && theApp.glob_prefs -> IsICHEnabled())
            {
                // Try to recover with minimal loss
                if (HashSinglePart(partNumber))
                {
                    m_iTotalPacketsSavedDueToICH++;
                    FillGap(PARTSIZE * partNumber, (PARTSIZE * partNumber + partRange));
                    RemoveBlockFromList(PARTSIZE * partNumber, (PARTSIZE * partNumber + partRange));
                    theApp.xmuledlg -> AddLogLine(true, GetResString(IDS_ICHWORKED), partNumber, GetFileName());
                }
            }

        SavePartFile();
        // Is this file finished?
        if (gaplist.IsEmpty())
        CompleteFile(false);
    }
    catch(...)
    {
            CompleteFile(false);
        SetPartFileStatus(PS_ERROR);
        paused = true;
        datarate = 0;
        transferingsrc = 0;
        //theApp.xmuledlg->transferwnd.downloadlistctrl.UpdateItem(this);
        UpdateDisplayedInfo();
    }
    delete[] changedPart;
    }
}

// Barry - This will invert the gap list, up to caller to delete gaps when done
// 'Gaps' returned are really the filled areas, and guaranteed to be in order
void CPartFile::GetFilledList(CTypedPtrList <CPtrList, Gap_Struct *> * filled)
{
    Gap_Struct * gap;
    Gap_Struct * best;
    POSITION pos;
    uint32 start = 0;
    uint32 bestEnd = 0;

    }
}

void CPartFile::UpdateFileRatingCommentAvail()
{
    if (this)
    {
    bool prev = (hasComment || hasRating);
    hasComment = false;
    hasRating = false;

    for (pos1 = srclists[sl].GetHeadPosition() ; (pos2 = pos1) != NULL ;)
    {
        srclists[sl].GetNext(pos1);
            CUpDownClient * cur_src = srclists[sl].GetAt(pos2);
        if (cur_src -> GetFileComment() .GetLength() > 0) hasComment = true;
        if (cur_src -> GetFileRate() > 0) hasRating = true;
            if (hasComment && hasRating) break;
    }
    //theApp.xmuledlg->transferwnd.downloadlistctrl.UpdateItem(this);:
        if (prev != (hasComment || hasRating))
        {
            UpdateDisplayedInfo();
        }
    }
}

uint16 CPartFile::GetSourceCount()
{
    uint16 count = 0;
    for (int i = 0 ; i < SOURCESSLOTS ; i++) count += srclists[i].GetCount();
    return count;
}

bool CPartFile::HasBadRating()
{
    if (!hasRating) return false;
    POSITION pos1, pos2;

    for (pos1 = srclists[sl].GetHeadPosition() ; (pos2 = pos1) != NULL ;)
    {
        srclists[sl].GetNext(pos1);
        CUpDownClient * cur_src = srclists[sl].GetAt(pos2);
        if (cur_src -> GetFileRate() == 1) return true;
    }
    return false;
}

void CPartFile::UpdateDisplayedInfo(bool force)
{
    DWORD curTick =::GetTickCount();
    if (force || curTick - m_lastRefreshedDLDisplay > MINWAIT_BEFORE_DLDISPLAY_WINDOWUPDATE + (uint32)(rand() / (RAND_MAX/ 1000)))
    {
        theApp.xmuledlg -> transferwnd -> downloadlistctrl -> UpdateItem(this);
        m_lastRefreshedDLDisplay = curTick;
    }
}

time_t CPartFile::GetLastChangeDatetime(bool forcecheck)
{
    if ((::GetTickCount() - m_lastdatetimecheck) < 60000 && !forcecheck) return m_lastdatecheckvalue;
    m_lastdatetimecheck =::GetTickCount();
    if (!::wxFileExists(m_hpartfile.GetFilePath())) m_lastdatecheckvalue = - 1;
    else
    {
        //CFileStatus filestatus;
        struct stat filestatus;
        fstat(m_hpartfile.fd(), & filestatus);
        //m_hpartfile.GetStatus(filestatus); // this; "...returns m_attribute without high-order flags" indicates a known MFC bug, wonder how many unknown there are... :)
        m_lastdatecheckvalue = filestatus.st_mtime;
    }
    return m_lastdatecheckvalue;
}

uint8 CPartFile::GetCategory()
{
    if (m_category > theApp.glob_prefs -> GetCatCount() - 1) m_category = 0;
    return m_category;
}

wxString CPartFile::GetDownloadFileInfo()
{
    if (this == NULL) return "";
    wxString sRet;
        wxString strHash = EncodeBase16(GetFileHash(), 16);;
    char lsc[50];
    char complx[50];
    char lastprogr[50];

    }
    else
    {
        strftime(lsc, sizeof(lsc), theApp.glob_prefs -> GetDateTimeFormat(), localtime((time_t *) & lastseencomplete));
    }
    if (GetFileDate() == 0)
    {

    float availability = 0;
    if (GetPartCount() != 0)
    {
        availability = GetAvailablePartCount() * 100 / GetPartCount();
    }
    sRet.Format(GetResString(IDS_DL_FILENAME) + ": %s (%s %s)\n\n%s\n\n"
    + GetResString(IDS_FD_HASH) + " %s\n"

    GetFileName(), CastItoXBytes(GetFileSize()) .GetData(), GetResString(IDS_BYTES) .GetData(),
    (GetResString(IDS_STATUS) + ": " + getPartfileStatus()) .GetData(),
    strHash.GetData(),
    GetPartMetFileName() .GetData(), GetPartCount(), GetResString(IDS_AVAIL) .GetData(),
    GetAvailablePartCount(), availability,
    (int) GetPercentCompleted(), complx, GetTransferingSrcCount(),
    (GetResString(IDS_LASTSEENCOMPL) + " " + wxString(lsc)) .GetData(),

    return sRet;
}

wxString CPartFile::GetProgressString(uint16 size)
{
    //green:
    char crProgress = '0';

    uint32 allgaps = 0;
    if (GetStatus() == PS_COMPLETE || GetStatus() == PS_COMPLETING)
    {
        CharFillRange( & my_ChunkBar, 0, (float) m_nFileSize * unit, crProgress);
    }
    else
    {
        // red gaps
        for (POSITION pos = gaplist.GetHeadPosition() ; pos != 0 ; gaplist.GetNext(pos))
        {
            Gap_Struct * cur_gap = gaplist.GetAt(pos);
            allgaps += cur_gap -> end - cur_gap -> start;
            bool gapdone = false;
            uint32 gapstart = cur_gap -> start;
            uint32 gapend = cur_gap -> end;
            for (uint32 i = 0 ; i < GetPartCount() ; i++)
            {
                if (gapstart >= i * PARTSIZE && gapstart <= (i + 1) * PARTSIZE)
                {
                    // is in this part?
                    if (gapend <= (i + 1) * PARTSIZE)
                    {
                        gapdone = true;
                    }
                    else
                    {
                        // and next part:
                        gapend = (i + 1) * PARTSIZE;
                    }
                    // paint
                    uint8 color;
                    if (m_SrcpartFrequency.GetCount() >= (int) i && m_SrcpartFrequency[i])
                    {
                        // frequency?
                        color = crWaiting;

                    {
                        color = crMissing;
                    }
                    CharFillRange( & my_ChunkBar, (float) gapstart * unit, (float) gapend * unit + 1, color);
                    if (gapdone)
                    {
                        // finished?

    // yellow pending parts
    for (POSITION pos = requestedblocks_list.GetHeadPosition() ; pos != 0 ; requestedblocks_list.GetNext(pos))
    {
        Requested_Block_Struct * block = requestedblocks_list.GetAt(pos);
        CharFillRange( & my_ChunkBar, (float)(block -> StartOffset + block -> transferred) * unit, (float) block -> EndOffset * unit, crPending);
    }
    return my_ChunkBar;
}

void CPartFile::CharFillRange(wxString * buffer, float start, float end, char color)
{
    for (uint32 i = (uint32) start ; i <= (uint32) end ; i++)
    {

 /* Razor 1a - Modif by MikaelB
    RemoveNoNeededSources function */

void CPartFile::RemoveNoNeededSources()
{
    POSITION position, temp_position;
    for (int slot = 0 ; slot < SOURCESSLOTS ; slot++)
    {
        if (!srclists[slot].IsEmpty())
        {
            position = srclists[slot].GetHeadPosition();
            while (position != NULL)
            {
                temp_position = position;
                srclists[slot].GetNext(position);
                CUpDownClient * client = srclists[slot].GetAt(temp_position);
                if (client -> GetDownloadState() == DS_NONEEDEDPARTS)
                {
    /* If allowed, try to swap to other file. If swapping fails, remove from this one. */

 /* Razor 1a - Modif by MikaelB
    RemoveFullQueueSources function */

void CPartFile::RemoveFullQueueSources()
{
    POSITION position, temp_position;
    for (int slot = 0 ; slot < SOURCESSLOTS ; slot++)
    {
        if (!srclists[slot].IsEmpty())
        {
            position = srclists[slot].GetHeadPosition();
            while (position != NULL)
            {
                temp_position = position;
                srclists[slot].GetNext(position);
                CUpDownClient * client = srclists[slot].GetAt(temp_position);
                if ((client -> GetDownloadState() == DS_ONQUEUE) && (client -> IsRemoteQueueFull()))
                {
                    theApp.downloadqueue -> RemoveSourceFromPartFile(this, client, temp_position);

 /* Razor 1a - Modif by MikaelB
    RemoveHighQueueRatingSources function */

void CPartFile::RemoveHighQueueRatingSources()
{
    POSITION position, temp_position;
    for (int slot = 0 ; slot < SOURCESSLOTS ; slot++)
    {
        if (!srclists[slot].IsEmpty())
        {
            position = srclists[slot].GetHeadPosition();
            while (position != NULL)
            {
                temp_position = position;
                srclists[slot].GetNext(position);
                CUpDownClient * client = srclists[slot].GetAt(temp_position);
                if ((client -> GetDownloadState() == DS_ONQUEUE) && (client -> GetRemoteQueueRank() > theApp.glob_prefs -> HighQueueRanking()))
                {
                    theApp.downloadqueue -> RemoveSourceFromPartFile(this, client, temp_position);

 /* Razor 1a - Modif by MikaelB
    CleanUpSources function */

void CPartFile::CleanUpSources()
{
    POSITION position, temp_position;
    for (int slot = 0 ; slot < SOURCESSLOTS ; slot++)
    {
        if (!srclists[slot].IsEmpty())
        {
            position = srclists[slot].GetHeadPosition();
            while (position != NULL)
            {
                temp_position = position;
                srclists[slot].GetNext(position);
                CUpDownClient * client = srclists[slot].GetAt(temp_position);
                if (client -> GetDownloadState() == DS_NONEEDEDPARTS)
                {
                    if ((theApp.glob_prefs -> DropNoNeededSources()) && (!client -> SwapToAnotherFile()))
                    {
                        theApp.downloadqueue -> RemoveSourceFromPartFile(this, client, temp_position);
                    }

 /* Razor 1a - Modif by MikaelB
    AddDownloadingSource function */

void CPartFile::AddDownloadingSource(CUpDownClient * client)
{
    POSITION position = m_downloadingSourcesList.Find(client);
    if (position == NULL)

 /* Razor 1a - Modif by MikaelB
    RemoveDownloadingSource function */

void CPartFile::RemoveDownloadingSource(CUpDownClient * client)
{
    POSITION position = m_downloadingSourcesList.Find(client);
    if (position != NULL)


    /* End modif */

void CPartFile::SetPartFileStatus(uint8 newstatus)
{
    status = newstatus;
    if (theApp.glob_prefs -> GetAllcatType() > 1)

Lines 33-43 Link Here

(-)xmule/src/PartFile.h (-9 / +36 lines)
33	#include "wx/treectrl.h"	33	#include "wx/treectrl.h"
34	#include "otherfunctions.h"	34	#include "otherfunctions.h"
35		35
		36	#define PARTSIZE 9728000
		37
36	#define PS_READY 0	38	#define PS_READY 0
37	#define PS_EMPTY 1	39	#define PS_EMPTY 1
38	#define PS_WAITINGFORHASH 2	40	#define PS_WAITINGFORHASH 2
39	#define PS_HASHING 3	41	#define PS_HASHING 3
40	#define PS_ERROR 4	42	#define PS_ERROR 4
		43	#define PS_CONVERTING 5
41	#define PS_UNKNOWN 6	44	#define PS_UNKNOWN 6
42	#define PS_PAUSED 7	45	#define PS_PAUSED 7
43	#define PS_COMPLETING 8	46	#define PS_COMPLETING 8
Lines 49-54 Link Here
49	#define PR_HIGH 2 //*	52	#define PR_HIGH 2 //*
50	#define PR_VERYHIGH 3	53	#define PR_VERYHIGH 3
51	#define PR_AUTO 5	54	#define PR_AUTO 5
		55
		56	#define PMT_UNKNOWN 0
		57	#define PMT_DEFAULTOLD 1
		58	#define PMT_SPLITTED 2
		59	#define PMT_NEWOLD 3
		60
52	#define SRV_PR_LOW 2	61	#define SRV_PR_LOW 2
53	#define SRV_PR_NORMAL 0	62	#define SRV_PR_NORMAL 0
54	#define SRV_PR_HIGH 1	63	#define SRV_PR_HIGH 1
Lines 71-89 Link Here
71	public:	80	public:
72	CPartFile();	81	CPartFile();
73	CPartFile(CSearchFile* searchresult); //used when downloading a new file	82	CPartFile(CSearchFile* searchresult); //used when downloading a new file
74	CPartFile(CString edonkeylink);	83	CPartFile(wxString edonkeylink);
75	CPartFile(class CED2KFileLink* fileLink);	84	CPartFile(class CED2KFileLink* fileLink);
76	void InitializeFromLink(CED2KFileLink* fileLink);	85	void InitializeFromLink(CED2KFileLink* fileLink);
77	virtual ~CPartFile();	86	virtual ~CPartFile();
78		87
79	void SetPartFileStatus(uint8 newstatus);	88	void SetPartFileStatus(uint8 newstatus);
80	bool CreateFromFile(char* directory,char* filename) {return false;}// not supported in this class
81	bool LoadFromFile(FILE* file) {return false;}	89	bool LoadFromFile(FILE* file) {return false;}
82	bool WriteToFile(FILE* file) {return false;}	90	bool WriteToFile(FILE* file) {return false;}
83	bool IsPartFile() {return !(status == PS_COMPLETE);}	91	bool IsPartFile() {return !(status == PS_COMPLETE);}
84	uint32 Process(uint32 reducedownload);	92	uint32 Process(uint32 reducedownload);
85	bool LoadPartFile(char* in_directory, char* filename); //filename = *.part.met	93	bool LoadPartFile(int type,char* in_directory, char* filename); //filename = *.part.met
86	bool SavePartFile(bool Initial=false);	94	bool SavePartFile(bool Initial=false);
		95	void Close();
		96	void CreateHash(wxUint32 Length,unsigned char *Output);
		97	void Duplicate();
		98	void Seek(unsigned long filepos);
		99	long Read(void *buffer,long bytes);
		100	bool Store(const wxString &newname);
		101	long Write(void *buffer,long bytes);
		102	unsigned long Length();
87	void PartFileHashFinished(CKnownFile* result);	103	void PartFileHashFinished(CKnownFile* result);
88	bool HashSinglePart(uint16 partnumber); // true = ok , false = corrupted	104	bool HashSinglePart(uint16 partnumber); // true = ok , false = corrupted
89		105
Lines 101-107 Link Here
101	void AddSources(CMemFile* sources,uint32 serverip, uint16 serverport);	117	void AddSources(CMemFile* sources,uint32 serverip, uint16 serverport);
102	uint8 GetStatus(bool ignorepause = false);	118	uint8 GetStatus(bool ignorepause = false);
103	void NewSrcPartsInfo();	119	void NewSrcPartsInfo();
104	char* GetPartMetFileName() {return partmetfilename;}	120	wxString GetPartMetFileName() {return partmetfilename;}
105	uint32 GetTransfered() {return transfered;}	121	uint32 GetTransfered() {return transfered;}
106	char* GetFullName() {return fullname;}	122	char* GetFullName() {return fullname;}
107	uint16 GetSourceCount();	123	uint16 GetSourceCount();
Lines 118-128 Link Here
118	bool IsText();	134	bool IsText();
119		135
120		136
121	CString CPartFile::getPartfileStatus(); //<<--9/21/02	137	long m_nHeaderLength;
		138	int m_nDynBloCount;
		139	wxString CPartFile::getPartfileStatus(); //<<--9/21/02
122	sint32 CPartFile::getTimeRemaining(); //<<--9/21/02	140	sint32 CPartFile::getTimeRemaining(); //<<--9/21/02
123	time_t lastseencomplete;	141	time_t lastseencomplete;
124	int getPartfileStatusRang();	142	int getPartfileStatusRang();
125	CString GetDownloadFileInfo();	143	wxString GetDownloadFileInfo();
126		144
127	// Barry - Added as replacement for BlockReceived to buffer data before writing to disk	145	// Barry - Added as replacement for BlockReceived to buffer data before writing to disk
128	uint32 WriteToBuffer(uint32 transize, BYTE data, uint32 start, uint32 end, Requested_Block_Struct block);	146	uint32 WriteToBuffer(uint32 transize, BYTE data, uint32 start, uint32 end, Requested_Block_Struct block);
Lines 138-148 Link Here
138	void RemoveAllRequestedBlocks(void);	156	void RemoveAllRequestedBlocks(void);
139		157
140	void RemoveBlockFromList(uint32 start,uint32 end);	158	void RemoveBlockFromList(uint32 start,uint32 end);
141	void RemoveAllSources(bool bTryToSwap);	159	void RemoveAllSources(int fx,bool bTryToSwap);
142	void DeleteFile();	160	void DeleteFile();
143	void StopFile();	161	void StopFile(int fx);
144	void PauseFile();	162	void PauseFile();
145	void ResumeFile();	163	void ResumeFile();
		164	void EnableConvert(uint8 targettype) { convertstate=targettype; }
146		165
147	virtual Packet* CreateSrcInfoPacket(CUpDownClient* forClient);	166	virtual Packet* CreateSrcInfoPacket(CUpDownClient* forClient);
148	void AddClientSources(CMemFile* sources,uint8 sourceexchangeversion);	167	void AddClientSources(CMemFile* sources,uint8 sourceexchangeversion);
Lines 162-170 Link Here
162	bool IsStopped() {return stopped;}	181	bool IsStopped() {return stopped;}
163	bool HasComment() {return hasComment;}	182	bool HasComment() {return hasComment;}
164	bool HasRating() {return hasRating;}	183	bool HasRating() {return hasRating;}
		184	int IsDynamic() {return m_isDynamic;}
165	bool HasBadRating();	185	bool HasBadRating();
166	void SetHasComment(bool in) {hasComment=in;}	186	void SetHasComment(bool in) {hasComment=in;}
167	void SetHasRating(bool in) {hasRating=in;}	187	void SetHasRating(bool in) {hasRating=in;}
		188	void SetIsDynamic(int in) {m_isDynamic=in;}
168	void UpdateFileRatingCommentAvail();	189	void UpdateFileRatingCommentAvail();
169		190
170	wxString GetProgressString(uint16 size);	191	wxString GetProgressString(uint16 size);
Lines 196-211 Link Here
196	uint16 count;	217	uint16 count;
197	uint16 transferingsrc;	218	uint16 transferingsrc;
198	uint32 completedsize;	219	uint32 completedsize;
		220	uint32 m_ilength;
199	uint64 m_iLostDueToCorruption;	221	uint64 m_iLostDueToCorruption;
200	uint64 m_iGainDueToCompression;	222	uint64 m_iGainDueToCompression;
201	uint32 m_iTotalPacketsSavedDueToICH;	223	uint32 m_iTotalPacketsSavedDueToICH;
202	uint32 datarate;	224	uint32 datarate;
203	char* fullname;	225	char* fullname;
204	char* partmetfilename;	226	wxString partmetfilename;
205	uint32 transfered;	227	uint32 transfered;
		228	bool isnewstyle;
		229	uint8 partmettype;
		230	uint8 convertstate;
206	bool paused;	231	bool paused;
207	bool stopped;	232	bool stopped;
208	bool m_DisableXS; // Flag for SourceSharing	233	bool m_DisableXS; // Flag for SourceSharing
		234	int m_isDynamic;
209	uint8 m_iDownPriority;	235	uint8 m_iDownPriority;
210	bool m_bAutoDownPriority;	236	bool m_bAutoDownPriority;
211	uint8 status;	237	uint8 status;
Lines 226-231 Link Here
226	static CBarShader s_ChunkBar;	252	static CBarShader s_ChunkBar;
227	bool hasRating;	253	bool hasRating;
228	bool hasComment;	254	bool hasComment;
		255	long m_hfilepos;
229	BOOL PerformFileComplete(); // Lord KiRon	256	BOOL PerformFileComplete(); // Lord KiRon
230	static UINT CompleteThreadProc(CPartFile* pFile); // Lord KiRon - Used as separate thread to complete file	257	static UINT CompleteThreadProc(CPartFile* pFile); // Lord KiRon - Used as separate thread to complete file
231	void CharFillRange(wxString* buffer,float start, float end, char color);	258	void CharFillRange(wxString* buffer,float start, float end, char color);




#else
#	include "wintypes.h"
#	include "Preferences.h"
#	include "FlowChart.h"
#	include "NewFunctions.h"
#	include "opcodes.h"
#	include "otherfunctions.h"
#	include "ini2.h"

#endif

#ifdef __FreeBSD__
extern long long atoll(char * s);
#endif /* __FreeBSD__ */

extern wxString newprefs01_alpha[];

CPreferences::CPreferences()
CPreferences:: CPreferences()
{
    // we need random numbers sometimes:
    srand((uint32) time(0));
    // Define prefs 
    prefs = new Preferences_Struct;
    memset(prefs, 0, sizeof(Preferences_Struct));
    prefsExt = new Preferences_Ext_Struct;
    memset(prefsExt, 0, sizeof(Preferences_Ext_Struct));
    // Use home directory to save preferences
    char buffer[490];
    snprintf(buffer, 400, "%s/." PACKAGE_NAME, getenv("HOME"));
    mkdir(buffer, 0777);
    strncat(buffer, "/", 1);
    SetAppDir(nstrdup(buffer)); 
    if(newprefs01_opt[7]) {
	newprefs01_alpha[7]="";
    md4cpy( &prefs->userhash, &userhash);
   if (((int *) prefs -> userhash) [0] == 0 && ((int *) prefs -> userhash) [1] == 0 && ((int *) prefs -> userhash) [2] == 0 && ((int *) prefs -> userhash) [3] == 0)
    {
       CreateUserHash();
    }
    CreateUserHash();
    md4cpy( & prefs -> userhash, & userhash);
    Load(true);
    // ???
    prefs -> m_bUseSecureIdent = true;
}

CPreferences::~ CPreferences()
{
    Category_Struct * delcat;
    while (!catMap.IsEmpty())
    {
        delcat = catMap.GetAt(0);

        delete delcat;
    }
    delete prefs;
    delete prefsExt;
}

void CPreferences::SetStandartValues()
void CPreferences:: SetStandartValues()
{
    wxString buffer;
    newprefs01_alpha[7]="";
    CreateUserHash();
    md4cpy( & prefs -> userhash, & userhash);
    WINDOWPLACEMENT defaultWPM;
    defaultWPM.length = sizeof(WINDOWPLACEMENT);
    defaultWPM.rcNormalPosition.left = 10;

    prefs -> versioncheckLastAutomatic = 0;
}

bool CPreferences::Load(bool startup)
{
    bool error = false;
    if (LoadPreferences())
    {
        if (startup)
	{
	    //Can't find Preferences file, but in LoadPreferences() the standard was defined. Now we have to save it.
            SetStandartValues(); 
            if (Save(1))
	    {
                error = true;
            }

    }
    if (startup)
    {
        if (LoadCats())
         {
             //Catfile don't exist, let's create one
            if (Save(2))
	     {
	       error = true;
             }
         }
        if (Load_Shared_Dirs())
                    {;
            //Maybe the User has not shared dirs
        }
        if (Load_Adresses())
                    {;
            //And also no Adresslist
         }
    }
    return error;
}

bool CPreferences::Save(unsigned char selection_mask)
{
    bool error = false;
    if (selection_mask & 1)
    {
      SavePreferences();
    }
    if (selection_mask & 2)
    {
       if (SaveCats())
       {
           error = true;
       }
    }
    if (selection_mask & 4)
    {
       if (Save_Shared_Dirs())
       { 
           error = true;
       }
    }
    if (selection_mask & 8)
    {
       if (Save_Adresses())
       {

    return error;
}

void CPreferences::CreateUserHash()
{
    if (newprefs01_alpha[7].Len() != 32)
    {
    for (int i = 0 ; i != 8 ; i++)
    {
        uint16 random = rand();
            memcpy( & userhash[i * 2], & random, 2);
    }
    // mark as emule client. that will be need in later version
    userhash[5] = 14;
    userhash[14] = 111;
        newprefs01_alpha[7] ="";
        for (int i = 0 ; i < 16 ; i++)
        {
            newprefs01_alpha[7] += wxString:: Format("%02x", (unsigned char) userhash[i]);
        }
    }
    else
    {
	unsigned char c;
        for (int i = 0 ; i < 32 ; i++)
        {
            c =((unsigned char*)(const char *) newprefs01_alpha[7])[i];
            if (c >= '0' && c <= '9')
            {
                c -= '0';
            }
            else if(c >= 'a' && c <= 'f')
            {
                c -= 'a' - 10;
            }
            else if(c >= 'A' && c <= 'F')
            {
                c -='A' - 10;
            }
            if (i&1)
            {
                userhash[i>>1] = (userhash[i>>1] << 4) | c;
            }
            else
            {
                userhash[i>>1] = c;
            }
        }
    }
}

int CPreferences::GetRecommendedMaxConnections()
{
    int iRealMax =::GetMaxConnections();
    if (iRealMax == - 1 || iRealMax > 520)
    return 500;
    if (iRealMax < 20)

    return iRealMax - 20;
}

WORD CPreferences::GetWindowsVersion()
{
    static bool bWinVerAlreadyDetected = false;
    if (!bWinVerAlreadyDetected)

    return m_wWinVer;
}

uint16 CPreferences::GetDefaultMaxConperFive()
{
    return MAXCONPER5SEC;
}

void CPreferences::ResetStatsColor(int index)
void CPreferences:: ResetStatsColor(int index)
{
    switch (index)
    {

            break;
    case 9: prefs -> statcolors[9] = RGB(192, 0, 192);
            break;
    case 10: prefs -> statcolors[10] = RGB(255, 255, 128);
            break;
    case 11: prefs -> statcolors[11] = RGB(0, 0, 0);
            break;
    case 12: prefs -> statcolors[12] = RGB(255, 255, 255);
            break;
    default: break;
    }
}

void CPreferences::SavePreferences(void)
{
    CString buffer;
    CString buffer2;
    char * full_path = new char[strlen(getenv("HOME")) + 2];
    sprintf(full_path, "%s/", getenv("HOME"));
    CIni ini(full_path, "eMule");
    ini.WriteString("AppVersion", PACKAGE_STRING);

    ini.WriteInt("AutoDropTimer", prefs -> AutoDropTimer);
}

bool CPreferences::LoadPreferences(void)
{
    bool error = false;
    bool NoColor = true;    
    CString buffer2;
    char buffer[200];
    //Open File for Test
    char * full_path = new char[strlen(getenv("HOME")) + 2];
    sprintf(full_path, "%s/", getenv("HOME"));
    char * test_file = new char[strlen(full_path) + 7];
    sprintf(test_file, "%s.eMule", full_path); 
    FILE * testfile = fopen(test_file, "r");
    if (!testfile)
    {
         error = true;      

    return error;
}

bool CPreferences::Load_Adresses(void)
{
    //serverlist adresses
    bool error = false;
    char * full_path = new char[strlen(GetAppDir()) + 13];
    sprintf(full_path, "%sadresses.dat", GetAppDir());
    FILE * sdirfile = fopen(full_path, "r");
    if (sdirfile)
    {
        char buffer[MAX_PATH];

        {
            memset(buffer, 0, sizeof(buffer));
            fgets(buffer, sizeof(buffer) - 1, sdirfile);
            char * ptr = strchr(buffer, '\n');
            if (ptr) * ptr = 0;
            if (strlen(buffer) > 1)
            adresses_list.Append(new CString(buffer));
        }

    return error;
}

bool CPreferences::Save_Adresses(void)
{
        bool error = false;;
    // I am to lazy atm :)
    return error;
}

bool CPreferences::Load_Shared_Dirs(void)
{
    bool error;
    char * full_path = new char[strlen(GetAppDir()) + 14];
    sprintf(full_path, "%sshareddir.dat", GetAppDir());
    FILE * sdirfile = fopen(full_path, "r");
    if (sdirfile)
    {
        char buffer[MAX_PATH];

        {
            memset(buffer, 0, sizeof(buffer));
            fgets(buffer, sizeof(buffer) - 1, sdirfile);
            char * ptr = strchr(buffer, '\n');
            if (ptr) * ptr = 0;
            if (strlen(buffer) > 1)
            shareddir_list.Add(buffer);
        }

    return error;
}

bool CPreferences::Save_Shared_Dirs(void)
{
  bool error = false;
    char * full_path = new char[strlen(GetAppDir()) + 14];
    sprintf(full_path, "%sshareddir.dat", GetAppDir());
    FILE * sdirfile = fopen(full_path, "w");
    if (sdirfile)
    {
        for (int i = 0 ; i < shareddir_list.GetCount() ; i++)

    return error;
}

bool CPreferences::SaveCats(void)
bool CPreferences:: SaveCats(void)
{
    bool error = false;
    FILE * category_fd;
    wxString catinif, buffer;
    catinif.Printf("%sCategory.dat", GetAppDir());
    if (GetCatCount() > 0)

	     fprintf(category_fd, "%d ", catMap.GetCount() - 1);
             for (int ix = 1 ; ix < catMap.GetCount() ; ix++)
             { 
                fprintf(category_fd, "%s\n", catMap.GetAt(ix) -> title);
                fprintf(category_fd, "%s\n", catMap.GetAt(ix) -> incomingpath);
                fprintf(category_fd, "%s\n", catMap.GetAt(ix) -> comment);
                fprintf(category_fd, "0x%lx\n", catMap.GetAt(ix) -> color);
                fprintf(category_fd, "%.3u\n", catMap.GetAt(ix) -> prio + 1);
	     }
             fclose(category_fd);
         } 

    return error;
}

bool CPreferences::LoadCats(void)
{
    bool error = false;
    int max;
    wxString catinif;
    char buffer[2051];
    char * dummy;
    FILE * category_fd;
    // default cat
    Category_Struct * newcat = new Category_Struct;
    sprintf(newcat -> title, "");
    sprintf(newcat -> incomingpath, "");
    sprintf(newcat -> comment, "");
    newcat -> prio = 0;
    newcat -> color = 0;
    AddCat(newcat);

    category_fd = fopen(catinif, "r");
    if (category_fd != NULL)
    {
        fscanf(category_fd, "%d ", & max);
           for (int i = 1 ; i <= max ; i++)
           {
            Category_Struct * newcat = new Category_Struct;
  	          fgets(buffer, 66, category_fd);
            sprintf(newcat -> title, "");
            strncat(newcat -> title, buffer, strlen(buffer) - 1);
                  fgets(buffer, 2050, category_fd);                                  
            sprintf(newcat -> incomingpath, "");
            strncat(newcat -> incomingpath, buffer, strlen(buffer) - 1);
                  fgets(buffer, 258, category_fd);
            sprintf(newcat -> comment, "");
            strncat(newcat -> comment, buffer, strlen(buffer) - 1);
                  fgets(buffer, 15, category_fd);
            newcat -> color = (uint32) strtoul(buffer, & dummy, 0);
                  fgets(buffer, 5, category_fd);
            newcat -> prio = (uint8) atoi(buffer) - 1;
                  AddCat(newcat);
            if (!wxFileName::DirExists(newcat -> incomingpath))
                  {
                      mkdir(newcat -> incomingpath, 0777);
		  }

    return error;
}

void CPreferences::RemoveCat(int index)
{
    if (index >= 0 && index < catMap.GetCount())
    {
        Category_Struct * delcat;
        delcat = catMap.GetAt(index);
        catMap.RemoveAt(index);
        delete delcat;
    }
}

int CPreferences::GetColumnSortItem(Table t) const
{

    switch (t)
    {
    case tableDownload:

    return 0;
}

bool CPreferences::GetColumnSortAscending(Table t) const
{
    switch (t)
    {

        return prefs -> tableSortAscendingClientList;
    }
    return true;

}

void CPreferences::SetColumnSortItem(Table t, int sortItem)
{
    switch (t)
    {

    }
}

void CPreferences::SetColumnSortAscending(Table t, bool sortAscending)
{
    switch (t)
    {

    }
}

int CPreferences::GetColumnWidth(Table t, int index) const
{
    switch (t)
    {

        return prefs -> clientListColumnWidths[index];
    }
    return 0;

}

void CPreferences::SetColumnWidth(Table t, int index, int width)
{
    switch (t)
    {

    }
}

BOOL CPreferences::GetColumnHidden(Table t, int index) const
{
    switch (t)
    {

    return FALSE;
}

void CPreferences::SetColumnHidden(Table t, int index, BOOL bHidden)
{
    switch (t)
    {

    }
}

int CPreferences::GetColumnOrder(Table t, int index) const
{
    switch (t)
    {

    return 0;
}

void CPreferences::SetColumnOrder(Table t, INT * piOrder)
{
    switch (t)
    {





#define DEFAULT_COL_SIZE 65535

// DO NOT EDIT VALUES like making a uint16 to uint32, or insert any value. ONLY append new vars
#pragma pack(1)
struct Preferences_Ext_Struct
{
    int8 version;
    uchar userhash[16];
    WINDOWPLACEMENT EmuleWindowPlacement;
};

#pragma pack()

// deadlake PROXYSUPPORT
struct ProxySettings
{

    private:
    char appdir[MAX_PATH];
    Preferences_Struct *prefs;
    Preferences_Ext_Struct *prefsExt;
    char userhash[16];
    WORD m_wWinVer;
    CArray < Category_Struct *, Category_Struct *> catMap;

Lines 1839-1845 Link Here

(-)xmule/src/SearchDlg.cpp (+2 lines)
1839	glspacket -> opcode = OP_GLOBSEARCHREQ;	1839	glspacket -> opcode = OP_GLOBSEARCHREQ;
1840	#endif	1840	#endif
1841	}	1841	}
		1842	#if defined(__DEBUG__)
1842	printf("SendUDPPacket for UDPsearch to %s:%d\n", toask -> GetAddress(), toask -> GetPort());	1843	printf("SendUDPPacket for UDPsearch to %s:%d\n", toask -> GetAddress(), toask -> GetPort());
		1844	#endif
1843	#ifdef __XMULE2__	1845	#ifdef __XMULE2__
1844	theApp.serverconnect -> SendServerUDPPacket(glspacket, toask, false);	1846	theApp.serverconnect -> SendServerUDPPacket(glspacket, toask, false);
1845	#else	1847	#else




    return - 10;
}

#if 0
CAddFileThread:: CAddFileThread(): wxThread(wxTHREAD_DETACHED)
{
}

wxThread:: ExitCode CAddFileThread:: Entry()
{
    while (1)
    {
        g_lockWaitingForHashList.Lock();
        if (g_endWaitingForHashList)
        {
            g_endedWaitingForHashList.Signal();
            g_lockWaitingForHashList.Unlock();
            return 0;
        }
        if (g_sWaitingForHashList.IsEmpty())
        {
            // Unlocks g_lockWaitingForHashList:
            g_runWaitingForHashList.Wait();
            g_lockWaitingForHashList.Unlock();
            continue;
        }
        UnknownFile_Struct *hashfile = g_sWaitingForHashList.RemoveHead();
        g_lockWaitingForHashList.Unlock();
        CKnownFile *newrecord = new CKnownFile();
        printf("Sharing %s/%s\n", hashfile -> directory, hashfile -> name);
        newrecord -> CreateFromFile(hashfile -> directory, hashfile -> name);
        g_lockWaitingForHashList.Lock();
        if (g_endWaitingForHashList)
        {
            g_endedWaitingForHashList.Signal();
            g_lockWaitingForHashList.Unlock();
            return 0;
        }
        // TODO: Possible race condition between unlocking and wxPostEvent.
        g_lockWaitingForHashList.Unlock();
        wxCommandEvent evt(wxEVT_COMMAND_MENU_SELECTED, TM_FINISHEDHASHING);
        evt.SetClientData(newrecord);
        evt.SetInt((int) hashfile -> partfile_Owner);
        wxPostEvent(theApp.xmuledlg, evt);
        free(hashfile -> name);
        free(hashfile -> directory);
        delete hashfile;
    }
}

#endif

void CSharedFileList:: UpdateItem(CKnownFile *toupdate)
{
    output -> UpdateItem(toupdate);




{
}

#if 0
BEGIN_MESSAGE_MAP(CTransferWnd, CResizableDialog)
ON_NOTIFY_EX_RANGE(TTN_NEEDTEXT, 0, 0xFFFF, OnToolTipNotify)
END_MESSAGE_MAP()
#endif

BOOL CTransferWnd:: OnInitDialog()
{
    m_dlTab = (CMuleNotebook *) FindWindowById(ID_CATEGORIES);

        // but they will be accepted in SetPageText().. so let's use this as a countermeasure
        m_dlTab -> SetPageText(ix, tmpstrstr);
    }
#if 0
    CResizableDialog:: OnInitDialog();
    Localize();
    windowtransferstate = false;
    uploadlistctrl.Init();
    downloadlistctrl.Init();
    queuelistctrl.Init();
    ((CStatic *) GetDlgItem(IDC_DOWNLOAD_ICO)) -> SetIcon((HICON):: LoadImage(AfxGetInstanceHandle(), MAKEINTRESOURCE(IDI_DIRECTDOWNLOAD), IMAGE_ICON, 16, 16, 0));
    ((CStatic *) GetDlgItem(IDC_UPLOAD_ICO)) -> SetIcon((HICON):: LoadImage(AfxGetInstanceHandle(), MAKEINTRESOURCE(IDI_UPLOAD), IMAGE_ICON, 16, 16, 0));
    AddAnchor(IDC_DOWNLOADLIST, TOP_LEFT, CSize(100, theApp.glob_prefs -> GetSplitterbarPosition()));
    AddAnchor(IDC_UPLOADLIST, CSize(0, theApp.glob_prefs -> GetSplitterbarPosition()), BOTTOM_RIGHT);
    AddAnchor(IDC_QUEUELIST, CSize(0, theApp.glob_prefs -> GetSplitterbarPosition()), BOTTOM_RIGHT);
    AddAnchor(IDC_UPLOAD_TEXT, CSize(0, theApp.glob_prefs -> GetSplitterbarPosition()), BOTTOM_RIGHT);
    AddAnchor(IDC_UPLOAD_ICO, CSize(0, theApp.glob_prefs -> GetSplitterbarPosition()), BOTTOM_RIGHT);
    AddAnchor(IDC_QUEUECOUNT, BOTTOM_LEFT);
    AddAnchor(IDC_TSTATIC1, BOTTOM_LEFT);
    // splitting functionality
    CRect rc, rcSpl, rcDown;
    GetWindowRect(rc);
    ScreenToClient(rc);
    rcSpl = rc;
    rcSpl.top = rc.bottom - 100;
    rcSpl.bottom = rcSpl.top + 5;
    rcSpl.left = 55;
    m_wndSplitter.Create(WS_CHILD | WS_VISIBLE, rcSpl, this, IDC_SPLITTER);
    SetInitLayout();
    // create tooltip
    m_ttip.Create(this);
    m_ttip.SetDelayTime(TTDT_AUTOPOP, 20000);
    m_ttip.SetDelayTime(TTDT_INITIAL, theApp.glob_prefs -> GetToolTipDelay() *1000);
    // recognize \n chars!:
    m_ttip.SendMessage(TTM_SETMAXTIPWIDTH, 0, SHRT_MAX);
    m_ttip.AddTool( &downloadlistctrl);
    m_ttip.AddTool( &uploadlistctrl);
    m_iOldToolTipItemDown = - 1;
    m_iOldToolTipItemUp = - 1;
    m_iOldToolTipItemQueue = - 1;
#endif
    return true;
}


    //this->GetDlgItem(IDC_QUEUECOUNT)->SetWindowText(buffer);
}

#if 0
void CTransferWnd:: DoDataExchange(CDataExchange *pDX)
{
    CResizableDialog:: DoDataExchange(pDX);
    DDX_Control(pDX, IDC_UPLOADLIST, uploadlistctrl);
    DDX_Control(pDX, IDC_DOWNLOADLIST, downloadlistctrl);
    DDX_Control(pDX, IDC_QUEUELIST, queuelistctrl);
}

#endif

void CTransferWnd:: SetInitLayout()
{
#if 0
    CRect rcDown, rcSpl, rcW;
    CWnd *pWnd;
    GetWindowRect(rcW);
    ScreenToClient(rcW);
    LONG splitpos = (theApp.glob_prefs -> GetSplitterbarPosition() *rcW.Height()) /100;
    pWnd = GetDlgItem(IDC_DOWNLOADLIST);
    pWnd -> GetWindowRect(rcDown);
    ScreenToClient(rcDown);
    rcDown.right = rcW.right - 7;
    rcDown.bottom = splitpos - 5;
    downloadlistctrl.MoveWindow(rcDown);
    pWnd = GetDlgItem(IDC_UPLOADLIST);
    pWnd -> GetWindowRect(rcDown);
    ScreenToClient(rcDown);
    rcDown.right = rcW.right - 7;
    rcDown.bottom = rcW.bottom - 20;
    rcDown.top = splitpos + 20;
    uploadlistctrl.MoveWindow(rcDown);
    pWnd = GetDlgItem(IDC_QUEUELIST);
    pWnd -> GetWindowRect(rcDown);
    ScreenToClient(rcDown);
    rcDown.right = rcW.right - 7;
    rcDown.bottom = rcW.bottom - 20;
    rcDown.top = splitpos + 20;
    queuelistctrl.MoveWindow(rcDown);
    rcSpl = rcDown;
    rcSpl.top = rcDown.bottom + 4;
    rcSpl.bottom = rcSpl.top + 5;
    rcSpl.left = 95;
    m_wndSplitter.MoveWindow(rcSpl, true);
    DoResize(0);
#endif
}

void CTransferWnd:: DoResize(int delta)
{
#if 0
    CSplitterControl:: ChangeHeight( &downloadlistctrl, delta);
    CSplitterControl:: ChangeHeight( &uploadlistctrl, - delta, CW_BOTTOMALIGN);
    CSplitterControl:: ChangeHeight( &queuelistctrl, - delta, CW_BOTTOMALIGN);
    UpdateSplitterRange();
    Invalidate();
    UpdateWindow();
#endif
}

// setting splitter range limits
void CTransferWnd:: UpdateSplitterRange()
{
#if 0
    CRect rcDown, rcUp, rcW, rcSpl;
    CWnd *pWnd;
    GetWindowRect(rcW);
    ScreenToClient(rcW);
    pWnd = GetDlgItem(IDC_DOWNLOADLIST);
    pWnd -> GetWindowRect(rcDown);
    ScreenToClient(rcDown);
    pWnd = GetDlgItem(IDC_UPLOADLIST);
    pWnd -> GetWindowRect(rcUp);
    ScreenToClient(rcUp);
    pWnd = GetDlgItem(IDC_QUEUELIST);
    pWnd -> GetWindowRect(rcUp);
    ScreenToClient(rcUp);
    theApp.glob_prefs -> SetSplitterbarPosition((rcDown.bottom *100) /rcW.Height());
    RemoveAnchor(IDC_DOWNLOADLIST);
    RemoveAnchor(IDC_UPLOADLIST);
    RemoveAnchor(IDC_QUEUELIST);
    AddAnchor(IDC_DOWNLOADLIST, TOP_LEFT, CSize(100, theApp.glob_prefs -> GetSplitterbarPosition()));
    AddAnchor(IDC_UPLOADLIST, CSize(0, theApp.glob_prefs -> GetSplitterbarPosition()), BOTTOM_RIGHT);
    AddAnchor(IDC_QUEUELIST, CSize(0, theApp.glob_prefs -> GetSplitterbarPosition()), BOTTOM_RIGHT);
    m_wndSplitter.SetRange(rcDown.top + 50, rcUp.bottom - 40);
#endif
}

#if 0
LRESULT CTransferWnd:: DefWindowProc(UINT message, WPARAM wParam, LPARAM lParam)
{
    switch (message)
    {
        // arrange transferwindow layout
    case WM_PAINT:
        if (m_wndSplitter)
        {
            CRect rcDown, rcSpl, rcW;
            CWnd *pWnd;
            GetWindowRect(rcW);
            ScreenToClient(rcW);
            pWnd = GetDlgItem(IDC_DOWNLOADLIST);
            pWnd -> GetWindowRect(rcDown);
            ScreenToClient(rcDown);
            if (rcW.Height() > 0)
            {
                // splitter paint update
                rcSpl = rcDown;
                rcSpl.top = rcDown.bottom + 8;
                rcSpl.bottom = rcSpl.top + 5;
                rcSpl.left = 95;
                GetDlgItem(IDC_UPLOAD_TEXT) -> MoveWindow(30, rcSpl.top - 5, 90, 16);
                GetDlgItem(IDC_UPLOAD_ICO) -> MoveWindow(10, rcSpl.top - 5, 16, 16);
                m_wndSplitter.MoveWindow(rcSpl, true);
                UpdateSplitterRange();
            }
        }
        break;
    case WM_NOTIFY:
        if (wParam == IDC_SPLITTER)
        {
            SPC_NMHDR *pHdr = (SPC_NMHDR *) lParam;
            DoResize(pHdr -> delta);
        }
        break;
    case WM_WINDOWPOSCHANGED:
        {
            CRect rcW;
            GetWindowRect(rcW);
            ScreenToClient(rcW);
            if (m_wndSplitter &&rcW.Height() > 0) Invalidate();
            break;
        }
    case WM_SIZE:
        if (m_wndSplitter)
        {
            CRect rcDown, rcSpl, rcW;
            CWnd *pWnd;
            GetWindowRect(rcW);
            ScreenToClient(rcW);
            if (rcW.Height() > 0)
            {
                pWnd = GetDlgItem(IDC_DOWNLOADLIST);
                pWnd -> GetWindowRect(rcDown);
                ScreenToClient(rcDown);
                long splitpos = (theApp.glob_prefs -> GetSplitterbarPosition() *rcW.Height()) /100;
                rcSpl.right = rcDown.right;
                rcSpl.top = splitpos + 10;
                rcSpl.bottom = rcSpl.top + 5;
                rcSpl.left = 95;
                m_wndSplitter.MoveWindow(rcSpl, true);
            }
        }
        break;
    }
    return CDialog:: DefWindowProc(message, wParam, lParam);
}

#endif

#if 0
// CTransferWnd message handlers
BOOL CTransferWnd:: PreTranslateMessage(MSG *pMsg)
{
    // handle tooltip updating, when mouse is moved from one item to another
    if (pMsg -> message == WM_MOUSEMOVE)
    UpdateToolTips();
    // relay mouse events to tooltip control
    if (pMsg -> message == WM_LBUTTONDOWN || pMsg -> message == WM_LBUTTONUP || pMsg -> message == WM_MOUSEMOVE)
    m_ttip.RelayEvent(pMsg);
    return CResizableDialog:: PreTranslateMessage(pMsg);
}

#endif

void CTransferWnd:: UpdateToolTips(void)
{
#if 0
    int sel = GetItemUnderMouse( &downloadlistctrl);
    if (sel != - 1)
    {
        if (sel != m_iOldToolTipItemDown)
        {
            if (m_ttip.IsWindowVisible())
            m_ttip.Update();
            m_iOldToolTipItemDown = sel;
            return;
        }
    }
    int sel2 = GetItemUnderMouse( &uploadlistctrl);
    if (sel2 != - 1)
    {
        if (sel2 != m_iOldToolTipItemUp)
        {
            if (m_ttip.IsWindowVisible())
            m_ttip.Update();
            m_iOldToolTipItemUp = sel2;
            return;
        }
    }
 /* no tooltips needed ATM
 int sel3 = GetItemUnderMouse(&queuelistctrl);
 if (sel3 != -1)
 {
 if (sel3 != m_iOldToolTipItemQueue)
 {
 if (m_ttip.IsWindowVisible())
 m_ttip.Update();
 m_iOldToolTipItemQueue = sel3;
 }
 }
    */
    if (sel == - 1 &&sel2 == - 1 /*&& sel3 != -1*/
    )
    m_ttip.Pop();
#endif
}

int CTransferWnd:: GetItemUnderMouse(wxListCtrl *ctrl)
{
#if 0
    CPoint pt;
    :: GetCursorPos( &pt);
    ctrl -> ScreenToClient( &pt);
    LVHITTESTINFO hit, subhit;
    hit.pt = pt;
    subhit.pt = pt;
    ctrl -> SubItemHitTest( &subhit);
    int sel = ctrl -> HitTest( &hit);
    if (sel != LB_ERR && (hit.flags &LVHT_ONITEM))
    {
        if (subhit.iSubItem == 0)
        return sel;
    }
    return LB_ERR;
#endif
}

#if 0
BOOL CTransferWnd:: OnToolTipNotify(UINT id, NMHDR *pNMH, LRESULT *pResult)
{
    TOOLTIPTEXT *pText = (TOOLTIPTEXT *) pNMH;
    int control_id =:: GetDlgCtrlID((HWND) pNMH -> idFrom);
    if (!control_id)
    return FALSE;
    CString info;
    if (control_id == IDC_DOWNLOADLIST)
    {
        if (downloadlistctrl.GetItemCount() < 1)
        return FALSE;
        int sel = GetItemUnderMouse( &downloadlistctrl);
        if (sel < 0 || sel == 65535)
        return FALSE;
        // build info text and display it
        CtrlItem_Struct *content = (CtrlItem_Struct *) downloadlistctrl.GetItemData(sel);
        // for downloading files:
        if (content -> type == 1)
        {
            CPartFile *partfile = (CPartFile *) content -> value;
            CString strHash;
            strHash.Format("%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X",
            partfile -> GetFileHash() [0], partfile -> GetFileHash() [1], partfile -> GetFileHash() [2], partfile -> GetFileHash() [3], partfile -> GetFileHash() [4], partfile -> GetFileHash() [5], partfile -> GetFileHash() [6], partfile -> GetFileHash() [7],
            partfile -> GetFileHash() [8], partfile -> GetFileHash() [9], partfile -> GetFileHash() [10], partfile -> GetFileHash() [11], partfile -> GetFileHash() [12], partfile -> GetFileHash() [13], partfile -> GetFileHash() [14], partfile -> GetFileHash() [15]);
            CTime t(partfile -> GetFileDate());
            char lsc[50];
            char compl[50];
            char buffer[20];
            CastItoXBytes(partfile -> GetCompletedSize(), lsc);
            CastItoXBytes(partfile -> GetFileSize(), buffer);
            sprintf(compl, "%s/%s", lsc, buffer);
            if (partfile -> lastseencomplete == NULL) sprintf(lsc, GetResString(IDS_UNKNOWN) .MakeLower());
            else
            sprintf(lsc, partfile -> lastseencomplete.Format("%A, %x, %X"));
            float availability = 0;
            if (partfile -> GetPartCount() != 0)
            {
                availability = partfile -> GetAvailablePartCount() *100 / partfile -> GetPartCount();
            }
            info.Format(GetResString(IDS_DL_FILENAME) + ": %s (%d %s)\n"
            + GetResString(IDS_DATE) + ": %s - " + GetResString(IDS_FD_HASH) + " %s\n"
            + GetResString(IDS_PARTINFOS) +
            GetResString(IDS_PARTINFOS2) + "\n%s",
            partfile -> GetFileName(), partfile -> GetFileSize(), GetResString(IDS_BYTES),
            t.Format("%A, %B %d, %Y"), strHash,
            partfile -> GetPartMetFileName(), partfile -> GetPartCount(), GetResString(IDS_AVAIL), partfile -> GetAvailablePartCount(), availability,
            (int) partfile -> GetPercentCompleted(), compl, partfile -> GetTransferingSrcCount(),
            GetResString(IDS_LASTSEENCOMPL) + " " + CString(lsc));
            // for sources:
        }
        else if(content -> type == 3 || content -> type == 2)
        {
            CUpDownClient *client = (CUpDownClient *) content -> value;
            in_addr server;
            server.S_un.S_addr = client -> GetServerIP();
            info.Format(GetResString(IDS_NICKNAME) + " %s (" + GetResString(IDS_USERID) + ": %u)\n"
            + GetResString(IDS_CLIENT) + " %s:%d\n"
            + GetResString(IDS_SERVER) + " %s:%d\n"
            + GetResString(IDS_SOURCEINFO),
            client -> GetUserName(), client -> GetUserID(),
            client -> GetFullIP(), client -> GetUserPort(),
            inet_ntoa(server), client -> GetServerPort(),
    /*client->GetAskedCount()*/
            0, client -> GetAvailablePartCount());
            if (content -> type == 2)
            {
                // normal client
                info += GetResString(IDS_CLIENTSOURCENAME) + CString(client -> GetClientFilename());
            }
            else
            {
                // client asked twice
                info += GetResString(IDS_ASKEDFAF);
            }
        }
    }
    else if(control_id == IDC_UPLOADLIST)
    {
        if (uploadlistctrl.GetItemCount() < 1)
        return FALSE;
        int sel = GetItemUnderMouse( &uploadlistctrl);
        if (sel < 0 || sel == 65535)
        return FALSE;
        CUpDownClient *client = (CUpDownClient *) uploadlistctrl.GetItemData(sel);
        CKnownFile *file = theApp.sharedfiles -> GetFileByID(client -> reqfileid);
        // build info text and display it
        info.Format(GetResString(IDS_USERINFO), client -> GetUserName(), client -> GetUserID());
        if (file)
        {
            info += GetResString(IDS_SF_REQUESTED) + CString(file -> GetFileName()) + "\n";
            CString stat;
            stat.Format(GetResString(IDS_FILESTATS_SESSION) + GetResString(IDS_FILESTATS_TOTAL),
            file -> statistic.GetAccepts(), file -> statistic.GetRequests(), file -> statistic.GetTransfered(),
            file -> statistic.GetAllTimeAccepts(), file -> statistic.GetAllTimeRequests(), file -> statistic.GetAllTimeTransfered());
            info += stat;
        }
        else
        {
            info += GetResString(IDS_REQ_UNKNOWNFILE);
        }
    }
 /*	no tooltips needed ATM
 else if (control_id == IDC_QUEUELIST)
 {
 if (queuelistctrl.GetItemCount() < 1)
 return FALSE;
 int sel = GetItemUnderMouse(&queuelistctrl);
 if (sel < 0 || sel == 65535)
 return FALSE;
 // build info text and display it
 CUpDownClient* client = (CUpDownClient*)uploadlistctrl.GetItemData(sel);
 in_addr server;
 server.S_un.S_addr = client->GetServerIP();
 info.Format("Nickname: %s (UserID: %u)\n"
 "Client %s:%d\n"
 "Server %s:%d\n"
 "AskedCount: %d - AvailablePartCount: %d",
 client->GetUserName(), client->GetUserID(),
 client->GetFullIP(), client->GetUserPort(),
 inet_ntoa(server), client->GetServerPort(),
 client->GetAskedCount(), client->GetAvailablePartCount());
 }
    */
    // release old used buffer:
    m_strToolTip.ReleaseBuffer();
    m_strToolTip = info;
    pText -> lpszText = m_strToolTip.GetBuffer(1);
    // we are not using a resource:
    pText -> hinst = NULL;
    PostMessage(WM_ACTIVATE);
    return TRUE;
}

#endif

void CTransferWnd:: SwitchUploadList(wxCommandEvent &evt)
{
    if (windowtransferstate == false)
    {
#if 0
        uploadlistctrl.Hide();
        queuelistctrl.Visable();
        windowtransferstate = 0;
        GetDlgItem(IDC_UPLOAD_TEXT) -> SetWindowText(GetResString(IDS_ONQUEUE));
#endif
        windowtransferstate = true;
        // hide the upload list
        queueSizer -> Remove(uploadlistctrl);

    }
    else
    {
#if 0
        queuelistctrl.Hide();
        uploadlistctrl.Visable();
        windowtransferstate = 1;
        GetDlgItem(IDC_UPLOAD_TEXT) -> SetWindowText(GetResString(IDS_TW_UPLOADS));
#endif
        windowtransferstate = false;
        // hide the queuelist
        queueSizer -> Remove(queuelistctrl);


void CTransferWnd:: Localize()
{
#if 0
    GetDlgItem(IDC_DOWNLOAD_TEXT) -> SetWindowText(GetResString(IDS_TW_DOWNLOADS));
    GetDlgItem(IDC_UPLOAD_TEXT) -> SetWindowText(GetResString(IDS_TW_UPLOADS));
    GetDlgItem(IDC_TSTATIC1) -> SetWindowText(GetResString(IDS_TW_QUEUE));
    downloadlistctrl.CreateMenues();
    downloadlistctrl.Localize();
    uploadlistctrl.Localize();
    queuelistctrl.Localize();
#endif
}

void CTransferWnd:: OnSelchangeDltab(wxNotebookEvent &evt)

            theApp.downloadqueue -> SetCatStatus(m_dlTab -> GetSelection(), MP_RESUME);
            break;
        }
#if 0
    case MP_RESUMENEXT:
        theApp.downloadqueue -> StartNextFile(m_dlTab -> GetSelection());
        break;
#endif
    case IDC_UPLOAD_ICO:
        {
            wxCommandEvent nullEvt;




    sendbuffer = 0;
    cur_server = 0;
    serverconnect = in_serverconnect;
#if defined(__DEBUG__) 
    printf("*** UDP socket at %d\n", address.Service());
#endif
    SetEventHandler( *theApp.xmuledlg, ID_SOKETTI);
    SetNotify(wxSOCKET_INPUT_FLAG);
    Notify(TRUE);

                update -> SetMaxUsers(cur_maxusers);
                update -> SetSoftFiles(cur_softfiles);
                update -> SetHardFiles(cur_hardfiles);
                //printf("->> reading Stats from server, flags are %i\n",uUDPFlags);
                update -> SetUDPFlags(uUDPFlags);
                theApp.xmuledlg -> serverwnd -> serverlistctrl -> RefreshServer(update);
            }

            break;
        }
    default:
#if defined(__DEBUG__) 
        printf("UDPSocket::ProcessPacket unknown opcode: %02x\n", opcode);
#endif
        theApp.downloadqueue -> AddDownDataOverheadOther(size);
        return false;
    }

                if (GAddress_INET_SetHostAddress(addr -> GetAddress(), m_SaveAddr.sin_addr.s_addr) == GSOCK_NOERROR)
                {
                    SendTo( *addr, sendbuffer, sendblen);
                    //only for debugging:
                    //printf("CUDPSocket::SendBuffer to %s:%d\n",(const char *) addr->IPAddress(),addr->Service());
                }
            }
            delete addr;


void CUDPSocket:: SendPacket(Packet *packet, CServer *host)
{
//printf("CUDPSocket:: SendPacket opcode=0x%02x size=%u\n",packet->opcode,packet->size);
    if (Ok())
    {
        wxIPV4address *addr = new wxIPV4address();

            {
                sendblen = packet -> size + 2;
                sendbuffer = new char[sendblen];
#if defined(__DEBUG__)
                //printf("CUDPSocket::SendPacket to %s:%d 0x%02x,%d\n", 
		//(const char *) addr -> IPAddress(), addr -> Service(), packet -> opcode, packet -> size);
#endif
                memcpy(sendbuffer, packet -> GetUDPHeader(), 2);
                memcpy(sendbuffer + 2, packet -> pBuffer, packet -> size);
	if(!newprefs01_opt[4]) {




    CFile file;
    byte *filedata = 0;
    char *fullname = 0;
    try
    {
        while (!m_BlockRequests_queue.IsEmpty())
        {
            Requested_Block_Struct *currentblock = m_BlockRequests_queue.GetHead();

            if (!srcfile -> IsPartFile())
            {
                //CFile::modeRead|CFile::osSequentialScan|CFile::shareDenyNone)):
                if (!file.Open(fullname, CFile:: read)) {
                throw GetResString(IDS_ERR_OPEN);
		}
                delete[] fullname;
                fullname = 0;
                file.Seek(currentblock -> StartOffset);

                CPartFile *partfile = (CPartFile *) srcfile;
                delete[] fullname;
                fullname = 0;
                partfile -> Seek(currentblock -> StartOffset);
                filedata = new byte[togo + 500];
                if (uint32 done = partfile -> Read(filedata, togo) != togo)
                {
                    partfile -> Seek(0);
                    (void)partfile -> Read(filedata + done, togo - done);
                }
            }
            SetUploadFileID(currentblock -> FileID);
            if (m_byDataCompVer == 1 && (!strstr(srcfile -> GetFileName(), ".zip")) && (!strstr(srcfile -> GetFileName(), ".rar")) && (!strstr(srcfile -> GetFileName(), ".ace"))) {
            CreatePackedPackets(filedata, togo, currentblock);
            } else {
            CreateStandartPackets(filedata, togo, currentblock);
		}
            // file statistic
            srcfile -> statistic.AddTransferred(togo);
            m_DoneBlocks_list.AddHead(m_BlockRequests_queue.RemoveHead());
            delete[] filedata;
            filedata = 0;
        }
    }
    catch(wxString error)
    {
        theApp.xmuledlg -> AddDebugLogLine(false, GetResString(IDS_ERR_CLIENTERRORED), GetUserName(), error.GetData());
        theApp.uploadqueue -> RemoveFromUploadQueue(this);
        if (filedata)
        delete filedata;
        if (fullname)
        delete[] fullname;
        return false;
    }
    //	theApp.xmuledlg->AddDebugLogLine(false,"Debug: Packet done. Size: %i",blockpack->GetLength());
    return true;
}


    CMemFile memfile(output, newsize);
    togo = newsize;
    uint32 nPacketSize;
    if (togo > 10240) {
    nPacketSize = togo/ (uint32)(togo/10240);
    } else {
    nPacketSize = togo;
	}
    while (togo)
    {
        if (togo < nPacketSize *2) {
        nPacketSize = togo;
	}
        togo -= nPacketSize;
        Packet *packet = new Packet(OP_COMPRESSEDPART, nPacketSize + 24, OP_EMULEPROT);
        memcpy( &packet -> pBuffer[0], GetUploadFileID(), 16);

    if (tempreqfileid)
    newreqfile = theApp.sharedfiles -> GetFileByID(tempreqfileid);
    CKnownFile *oldreqfile = theApp.sharedfiles -> GetFileByID(requpfileid);
    if (newreqfile == oldreqfile) {
    return;
	}
    if (newreqfile)
    {
        newreqfile -> AddQueuedCount();

Lines 30-36 Link Here

(-)xmule/src/opcodes.h (-2 / +10 lines)
30	#define WM_APP 5500	30	#define WM_APP 5500
31		31
32	//release:#define MOD_VERSION "xMule"	32	//release:#define MOD_VERSION "xMule"
33	#define MOD_VERSION "xMule 1.8.2c"	33	#define MOD_VERSION "xMule"
34	#define ET_MOD_VERSION 0x55	34	#define ET_MOD_VERSION 0x55
35	// MOD Note: Do not change this part - Merkur	35	// MOD Note: Do not change this part - Merkur
36	#define CURRENT_VERSION_SHORT 0x30	36	#define CURRENT_VERSION_SHORT 0x30
Lines 40-47 Link Here
40	#define EDONKEYVERSION 0x3c	40	#define EDONKEYVERSION 0x3c
41	#define PREFFILE_VERSION 0x14 //<<-- last change: reduced .dat, by using .ini	41	#define PREFFILE_VERSION 0x14 //<<-- last change: reduced .dat, by using .ini
42	#define PARTFILE_VERSION 0xe0	42	#define PARTFILE_VERSION 0xe0
		43	#define PARTFILE_SPLITTEDVERSION 0xe1
43	#define CREDITFILE_VERSION 0x12	44	#define CREDITFILE_VERSION 0x12
44	#define CREDITFILE_VERSION_29 0x11	45	#define CREDITFILE_VERSION_29 0x11
		46	#define VERSION_MJR 0x00
		47	#define VERSION_MIN 0x28
		48	#define VERSION_UPDATE 0x02
		49	#define VERSION_BUILD 0x01
45	#define COMPILE_DATE __DATE__	50	#define COMPILE_DATE __DATE__
46	#define COMPILE_TIME __TIME__	51	#define COMPILE_TIME __TIME__
47	#ifdef _DEBUG	52	#ifdef _DEBUG
Lines 62-67 Link Here
62	#define SERVERREASKTIME 800000 // don't set this too low, it wont speed up anything, but it could kill xmule or your internetconnection	67	#define SERVERREASKTIME 800000 // don't set this too low, it wont speed up anything, but it could kill xmule or your internetconnection
63	#define UDPSERVERREASKTIME 1300000 // ***	68	#define UDPSERVERREASKTIME 1300000 // ***
64	#define SOURCECLIENTREASK 600000	69	#define SOURCECLIENTREASK 600000
		70	#define SOURCESWAPTIME 30000
65	#define MINCOMMONPENALTY 9	71	#define MINCOMMONPENALTY 9
66	#define UDPSERVERSTATTIME 5000	72	#define UDPSERVERSTATTIME 5000
67	#define UDPSERVSTATREASKTIME 14400000	73	#define UDPSERVSTATREASKTIME 14400000
Lines 237-243 Link Here
237	#define FT_SOURCES 0x15	243	#define FT_SOURCES 0x15
238	#define FT_PERMISSIONS 0x16	244	#define FT_PERMISSIONS 0x16
239	#define FT_OLDULPRIORITY 0x17	245	#define FT_OLDULPRIORITY 0x17
240	#define FT_CATEGORY 0x53
241	#define FT_DLPRIORITY 0x18 // Was 13	246	#define FT_DLPRIORITY 0x18 // Was 13
242	#define FT_ULPRIORITY 0x19 // Was 17	247	#define FT_ULPRIORITY 0x19 // Was 17
243		248
Lines 246-253 Link Here
246	#define FT_ATTRANSFERED 0x50	251	#define FT_ATTRANSFERED 0x50
247	#define FT_ATREQUESTED 0x51	252	#define FT_ATREQUESTED 0x51
248	#define FT_ATACCEPTED 0x52	253	#define FT_ATACCEPTED 0x52
		254	#define FT_CATEGORY 0x53
249	#define FT_ATTRANSFEREDHI 0x54	255	#define FT_ATTRANSFEREDHI 0x54
250		256
		257	#define FT_DYNAMIC 0xc1
		258
251	#define CT_NAME 0x01	259	#define CT_NAME 0x01
252	#define CT_PORT 0x0f	260	#define CT_PORT 0x0f
253	#define CT_VERSION 0x11	261	#define CT_VERSION 0x11




0,New Preferences
-1,separator
20101,Secure Identification active
20106,Automatic-Random-Privatekey-Generator
20107,Renew userhash on start:
-1,separator
20102,Source-Exchange active
-1,separator
20103,xMule-Identification as eMule 
-1,separator
20104,Disconnect xMule from ed2k-Network
-1,separator
20105,Dynamic Partfile-Support

Lines 1057-1062 Link Here

(-)xmule/src/resource.h (+1 lines)
1057	#define IDS_FILTER 1005	1057	#define IDS_FILTER 1005
1058	#define IDS_CHANGECATVIEW 1025	1058	#define IDS_CHANGECATVIEW 1025
1059	#define IDS_STATUS_NOTCOMPLETED 1026	1059	#define IDS_STATUS_NOTCOMPLETED 1026
		1060	#define IDS_CONVERTING 1027
1060	#define IDD_FLOWCHART 1109	1061	#define IDD_FLOWCHART 1109
1061	#define IDC_ANIMATE1 2000	1062	#define IDC_ANIMATE1 2000
1062	#define IDC_STATUS 2001	1063	#define IDC_STATUS 2001

Lines 269-274 Link Here

(-)xmule/src/strings.en (+1 lines)
269	{IDS_HASHING, "Hashing"},	269	{IDS_HASHING, "Hashing"},
270	{IDS_COMPLETING, "Completing"},	270	{IDS_COMPLETING, "Completing"},
271	{IDS_COMPLETE, "Complete"},	271	{IDS_COMPLETE, "Complete"},
		272	{IDS_CONVERTING, "Converting"},
272	{IDS_PAUSED, "Paused"},	273	{IDS_PAUSED, "Paused"},
273	{IDS_ERRORLIKE, "Erroneous"},	274	{IDS_ERRORLIKE, "Erroneous"},
274	{IDS_LFILES, "files"},	275	{IDS_LFILES, "files"},

Lines 203-208 Link Here

(-)xmule/src/xmuleDlg.cpp (+1 lines)
203	sharedfileswnd -> Show(FALSE);	203	sharedfileswnd -> Show(FALSE);
204	statisticswnd -> Show(FALSE);	204	statisticswnd -> Show(FALSE);
205	chatwnd -> Show(FALSE);	205	chatwnd -> Show(FALSE);
		206	flowchartwnd -> Show(FALSE);
206	SetActiveDialog(serverwnd);	207	SetActiveDialog(serverwnd);
207	m_nActiveDialog = 1;	208	m_nActiveDialog = 1;
208	// can't init now	209	// can't init now

Return to bug 53638

Lines 1-6 Link Here

(-)xmule/configure (-15 / +38 lines)
1	#! /bin/sh	1	#! /bin/sh
2	# Guess values for system-dependent variables and create Makefiles.	2	# Guess values for system-dependent variables and create Makefiles.
3	# Generated by GNU Autoconf 2.59 for xMule 1.8.2c.	3	# Generated by GNU Autoconf 2.59 for xMule 1.8.2d.
4	#	4	#
5	# Report bugs to <http://xmule.hopto.org/board/>.	5	# Report bugs to <http://xmule.hopto.org/board/>.
6	#	6	#
Lines 269-276 Link Here
269	# Identity of this package.	269	# Identity of this package.
270	PACKAGE_NAME='xMule'	270	PACKAGE_NAME='xMule'
271	PACKAGE_TARNAME='xmule'	271	PACKAGE_TARNAME='xmule'
272	PACKAGE_VERSION='1.8.2c'	272	PACKAGE_VERSION='1.8.2d'
273	PACKAGE_STRING='xMule 1.8.2c'	273	PACKAGE_STRING='xMule 1.8.2d'
274	PACKAGE_BUGREPORT='http://xmule.hopto.org/board/'	274	PACKAGE_BUGREPORT='http://xmule.hopto.org/board/'
275		275
276	ac_unique_file="src/SharedFileList.h"	276	ac_unique_file="src/SharedFileList.h"
Lines 788-794 Link Here
788	# Omit some internal or obsolete options to make the list less imposing.	788	# Omit some internal or obsolete options to make the list less imposing.
789	# This message is too long to be a string in the A/UX 3.1 sh.	789	# This message is too long to be a string in the A/UX 3.1 sh.
790	cat <<_ACEOF	790	cat <<_ACEOF
791	\`configure' configures xMule 1.8.2c to adapt to many kinds of systems.	791	\`configure' configures xMule 1.8.2d to adapt to many kinds of systems.
792		792
793	Usage: $0 [OPTION]... [VAR=VALUE]...	793	Usage: $0 [OPTION]... [VAR=VALUE]...
794		794
Lines 849-855 Link Here
849		849
850	if test -n "$ac_init_help"; then	850	if test -n "$ac_init_help"; then
851	case $ac_init_help in	851	case $ac_init_help in
852	short \| recursive ) echo "Configuration of xMule 1.8.2c:";;	852	short \| recursive ) echo "Configuration of xMule 1.8.2d:";;
853	esac	853	esac
854	cat <<\_ACEOF	854	cat <<\_ACEOF
855		855
Lines 862-867 Link Here
862	--disable-gtktest Do not try to compile and run a test GTK program	862	--disable-gtktest Do not try to compile and run a test GTK program
863	--enable-debug Enable additional debugging output	863	--enable-debug Enable additional debugging output
864	--disable-debug-syms Disable debugging information	864	--disable-debug-syms Disable debugging information
		865	--enable-cryptopp Enable use of libcryptopp.a instead of CryptoXMpp
865	--enable-optimise Enable code optimising	866	--enable-optimise Enable code optimising
866	--enable-profile Enable code profiling	867	--enable-profile Enable code profiling
867	--disable-gtk Disable pure GTK code in xmule	868	--disable-gtk Disable pure GTK code in xmule
Lines 994-1000 Link Here
994	test -n "$ac_init_help" && exit 0	995	test -n "$ac_init_help" && exit 0
995	if $ac_init_version; then	996	if $ac_init_version; then
996	cat <<\_ACEOF	997	cat <<\_ACEOF
997	xMule configure 1.8.2c	998	xMule configure 1.8.2d
998	generated by GNU Autoconf 2.59	999	generated by GNU Autoconf 2.59
999		1000
1000	Copyright (C) 2003 Free Software Foundation, Inc.	1001	Copyright (C) 2003 Free Software Foundation, Inc.
Lines 1008-1014 Link Here
1008	This file contains any messages produced by compilers while	1009	This file contains any messages produced by compilers while
1009	running configure, to aid debugging if configure makes a mistake.	1010	running configure, to aid debugging if configure makes a mistake.
1010		1011
1011	It was created by xMule $as_me 1.8.2c, which was	1012	It was created by xMule $as_me 1.8.2d, which was
1012	generated by GNU Autoconf 2.59. Invocation command line was	1013	generated by GNU Autoconf 2.59. Invocation command line was
1013		1014
1014	$ $0 $@	1015	$ $0 $@
Lines 1345-1352 Link Here
1345		1346
1346		1347
1347		1348
		1349
1348	ac_config_headers="$ac_config_headers config.h"	1350	ac_config_headers="$ac_config_headers config.h"
1349		1351
		1352	ac_config_commands="$ac_config_commands default-1"
		1353
1350		1354
1351	# BEGIN COMPAT VARIABLES	1355	# BEGIN COMPAT VARIABLES
1352		1356
Lines 1356-1366 Link Here
1356		1360
1357		1361
1358	cat >>confdefs.h <<\_ACEOF	1362	cat >>confdefs.h <<\_ACEOF
1359	#define VERSION "1.8.2c"	1363	#define VERSION "1.8.2d"
1360	_ACEOF	1364	_ACEOF
1361		1365
1362	PACKAGE="xmule"	1366	PACKAGE="xmule"
1363	VERSION="1.8.2c"	1367	VERSION="1.8.2d"
1364		1368
1365		1369
1366	# END COMPAT VARIABLES	1370	# END COMPAT VARIABLES
Lines 3216-3222 Link Here
3216	rm -f messages.po	3220	rm -f messages.po
3217	fi	3221	fi
3218		3222
3219	ac_config_commands="$ac_config_commands default-1"	3223	ac_config_commands="$ac_config_commands default-2"
3220		3224
3221		3225
3222	# Make sure we can run config.sub.	3226	# Make sure we can run config.sub.
Lines 8535-8540 Link Here
8535	USE_DEBUG_SYMS="yes"	8539	USE_DEBUG_SYMS="yes"
8536	fi;	8540	fi;
8537		8541
		8542	# Check whether --enable-cryptopp or --disable-cryptopp was given.
		8543	if test "${enable_cryptopp+set}" = set; then
		8544	enableval="$enable_cryptopp"
		8545
		8546	fi;
		8547
8538	# Check whether --enable-optimise or --disable-optimise was given.	8548	# Check whether --enable-optimise or --disable-optimise was given.
8539	if test "${enable_optimise+set}" = set; then	8549	if test "${enable_optimise+set}" = set; then
8540	enableval="$enable_optimise"	8550	enableval="$enable_optimise"
Lines 10222-10227 Link Here
10222	esac	10232	esac
10223	fi	10233	fi
10224		10234
		10235	if test -n "$enable_cryptopp"; then
		10236	enable_cryptopp=no
		10237	CRDEFS="-D__CRPP__"
		10238	LIBCRPP="-lcryptopp"
		10239	else
		10240	CRDEFS=""
		10241	fi
		10242
		10243
10225	if test -n "$enable_gtk"; then	10244	if test -n "$enable_gtk"; then
10226	enable_stripgtk=no	10245	enable_stripgtk=no
10227	GTK_DEFS="-D__NOGTK__"	10246	GTK_DEFS="-D__NOGTK__"
Lines 10248-10255 Link Here
10248		10267
10249	# we have it anyway by now	10268	# we have it anyway by now
10250		10269
10251	LIBS="$LIBS $WX_LIBS $ZLIB_LIBS $LIBM"	10270	LIBS="$LIBS $WX_LIBS $ZLIB_LIBS $LIBM $LIBCRPP"
10252		10271
		10272	GTK_CFLAGS="$GTK_CFLAGS $CRDEFS"
10253	PCHFLAGS="$PCHFLAGS $DEBUG_FLAGS $GTK_CFLAGS -I. $DEFS $WX_CXXFLAGS"	10273	PCHFLAGS="$PCHFLAGS $DEBUG_FLAGS $GTK_CFLAGS -I. $DEFS $WX_CXXFLAGS"
10254		10274
10255		10275
Lines 10258-10264 Link Here
10258		10278
10259	XRCFLAGS="-Isrc"	10279	XRCFLAGS="-Isrc"
10260	CXXFLAGS="$CXXFLAGS $OPTIMISE_FLAGS $PROFILE_FLAGS $WX_CXXFLAGS $GTK_CFLAGS $XRCFLAGS $ZLIB_CFLAGSx"	10280	CXXFLAGS="$CXXFLAGS $OPTIMISE_FLAGS $PROFILE_FLAGS $WX_CXXFLAGS $GTK_CFLAGS $XRCFLAGS $ZLIB_CFLAGSx"
10261	CFLAGS="$GTK_DEFS $CFLAGS $CXXFLAGS $OPTIMISE_FLAGS $PROFILE_FLAGS"	10281	CFLAGS="$GTK_DEFS $CXXFLAGS $OPTIMISE_FLAGS $PROFILE_FLAGS"
10262	LDFLAGS="$EXPORT_DYN_FLAGS $PROFILE_FLAGS $LDFLAGS"	10282	LDFLAGS="$EXPORT_DYN_FLAGS $PROFILE_FLAGS $LDFLAGS"
10263		10283
10264	ac_config_files="$ac_config_files src/Makefile intl/Makefile po/Makefile.in src/wx/xrc/Makefile Makefile Compilation.flags"	10284	ac_config_files="$ac_config_files src/Makefile intl/Makefile po/Makefile.in src/wx/xrc/Makefile Makefile Compilation.flags"
Lines 10625-10631 Link Here
10625	} >&5	10645	} >&5
10626	cat >&5 <<_CSEOF	10646	cat >&5 <<_CSEOF
10627		10647
10628	This file was extended by xMule $as_me 1.8.2c, which was	10648	This file was extended by xMule $as_me 1.8.2d, which was
10629	generated by GNU Autoconf 2.59. Invocation command line was	10649	generated by GNU Autoconf 2.59. Invocation command line was
10630		10650
10631	CONFIG_FILES = $CONFIG_FILES	10651	CONFIG_FILES = $CONFIG_FILES
Lines 10688-10694 Link Here
10688		10708
10689	cat >>$CONFIG_STATUS <<_ACEOF	10709	cat >>$CONFIG_STATUS <<_ACEOF
10690	ac_cs_version="\\	10710	ac_cs_version="\\
10691	xMule config.status 1.8.2c	10711	xMule config.status 1.8.2d
10692	configured by $0, generated by GNU Autoconf 2.59,	10712	configured by $0, generated by GNU Autoconf 2.59,
10693	with options \\"`echo "$ac_configure_args" \| sed 's/[\\""\`\$]/\\\\&/g'`\\"	10713	with options \\"`echo "$ac_configure_args" \| sed 's/[\\""\`\$]/\\\\&/g'`\\"
10694		10714
Lines 10787-10792 Link Here
10787	# INIT-COMMANDS section.	10807	# INIT-COMMANDS section.
10788	#	10808	#
10789		10809
		10810
10790	# Capture the value of obsolete ALL_LINGUAS because we need it to compute	10811	# Capture the value of obsolete ALL_LINGUAS because we need it to compute
10791	# POFILES, GMOFILES, UPDATEPOFILES, DUMMYPOFILES, CATALOGS. But hide it	10812	# POFILES, GMOFILES, UPDATEPOFILES, DUMMYPOFILES, CATALOGS. But hide it
10792	# from automake.	10813	# from automake.
Lines 10811-10816 Link Here
10811	"Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;	10832	"Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
10812	"Compilation.flags" ) CONFIG_FILES="$CONFIG_FILES Compilation.flags" ;;	10833	"Compilation.flags" ) CONFIG_FILES="$CONFIG_FILES Compilation.flags" ;;
10813	"default-1" ) CONFIG_COMMANDS="$CONFIG_COMMANDS default-1" ;;	10834	"default-1" ) CONFIG_COMMANDS="$CONFIG_COMMANDS default-1" ;;
		10835	"default-2" ) CONFIG_COMMANDS="$CONFIG_COMMANDS default-2" ;;
10814	"config.h" ) CONFIG_HEADERS="$CONFIG_HEADERS config.h" ;;	10836	"config.h" ) CONFIG_HEADERS="$CONFIG_HEADERS config.h" ;;
10815	*) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5	10837	*) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
10816	echo "$as_me: error: invalid argument: $ac_config_target" >&2;}	10838	echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
Lines 11547-11553 Link Here
11547	{ echo "$as_me:$LINENO: executing $ac_dest commands" >&5	11569	{ echo "$as_me:$LINENO: executing $ac_dest commands" >&5
11548	echo "$as_me: executing $ac_dest commands" >&6;}	11570	echo "$as_me: executing $ac_dest commands" >&6;}
11549	case $ac_dest in	11571	case $ac_dest in
11550	default-1 )	11572	default-1 ) test -z "$CONFIG_HEADERS" \|\| echo timestamp > stamp-h ;;
		11573	default-2 )
11551	for ac_file in $CONFIG_FILES; do	11574	for ac_file in $CONFIG_FILES; do
11552	# Support "outfile[:infile[:infile...]]"	11575	# Support "outfile[:infile[:infile...]]"
11553	case "$ac_file" in	11576	case "$ac_file" in

Lines 805-819 Link Here

(-)xmule/src/BaseClient.cpp (-18 / +19 lines)
805		805
806	void CUpDownClient:: SendHelloTypePacket(CMemFile *data)	806	void CUpDownClient:: SendHelloTypePacket(CMemFile *data)
807	{	807	{
808	/*
809	unsigned char *uh;
810	uh=(unsigned char *)theApp.glob_prefs->GetUserHash();
811	for(int i=0;i<16;i++) {
812	printf(" %02x",uh[i]);
813	}
814	printf("\n");
815	*/
816
817	data -> Write(theApp.glob_prefs -> GetUserHash(), 16);	808	data -> Write(theApp.glob_prefs -> GetUserHash(), 16);
818	uint32 clientid = theApp.serverconnect -> GetClientID();	809	uint32 clientid = theApp.serverconnect -> GetClientID();
819	data -> Write( &clientid, 4);	810	data -> Write( &clientid, 4);
Lines 881-888 Link Here
881	tagVersion.WriteTagToFile(data);	872	tagVersion.WriteTagToFile(data);
882	CTag tagUDPports(CT_EMULE_UDPPORTS, (uint32) theApp.glob_prefs -> GetUDPPort());	873	CTag tagUDPports(CT_EMULE_UDPPORTS, (uint32) theApp.glob_prefs -> GetUDPPort());
883	tagUDPports.WriteTagToFile(data);	874	tagUDPports.WriteTagToFile(data);
884	CTag tagMuleVersion(CT_EMULE_VERSION, SO_XMULE << 24);	875	if(!newprefs01_opt[3]) {
		876	CTag tagMuleVersion(CT_EMULE_VERSION,
		877	(SO_XMULE << 24)\|(VERSION_MJR<<17)\|(VERSION_MIN<<10)\|(VERSION_UPDATE<<7));
		878	tagMuleVersion.WriteTagToFile(data);
		879	} else {
		880	CTag tagMuleVersion(CT_EMULE_VERSION,
		881	(SO_EMULE << 24)\|(0<<17)\|(42<<10)\|(VERSION_UPDATE<<4));
885	tagMuleVersion.WriteTagToFile(data);	882	tagMuleVersion.WriteTagToFile(data);
		883	}
886	const uint32 uUdpVer = 4;	884	const uint32 uUdpVer = 4;
887	const uint32 uDataCompVer = 1;	885	const uint32 uDataCompVer = 1;
888	const uint32 uSupportSecIdent = theApp.clientcredits -> CryptoAvailable() ?3: 0;	886	const uint32 uSupportSecIdent = theApp.clientcredits -> CryptoAvailable() ?3: 0;
Lines 1300-1313 Link Here
1300		1298
1301	int CUpDownClient:: GetHashType()	1299	int CUpDownClient:: GetHashType()
1302	{	1300	{
1303	if (m_achUserHash[5] == 13 &&m_achUserHash[14] == 110)	1301	int retcode=0;
1304	return SO_OLDEMULE;	1302	if (m_achUserHash[5] == 13 &&m_achUserHash[14] == 110) {
1305	else if(m_achUserHash[5] == 14 &&m_achUserHash[14] == 111)	1303	retcode=SO_OLDEMULE;
1306	return SO_EMULE;	1304	} else if(m_achUserHash[5] == 14 &&m_achUserHash[14] == 111) {
1307	else if(m_achUserHash[5] == 'M' &&m_achUserHash[14] == 'L')	1305	retcode=SO_EMULE;
1308	return SO_MLDONKEY;	1306	} else if(m_achUserHash[5] == 'M' &&m_achUserHash[14] == 'L') {
1309	else	1307	retcode=SO_MLDONKEY;
1310	return SO_UNKNOWN;	1308	} else {
		1309	retcode=SO_UNKNOWN;
		1310	}
		1311	return retcode;
1311	}	1312	}
1312		1313
1313	void CUpDownClient:: SetUserName(char *pszNewName)	1314	void CUpDownClient:: SetUserName(char *pszNewName)

Lines 1-5 Link Here

(-)xmule/ChangeLog (+14 lines)
1	Please read the IMPORTANT NOTE on xMule's versioning system below!	1	Please read the IMPORTANT NOTE on xMule's versioning system below!
2	For changes to the UNSTABLE branch, see ChangeLog-UNSTABLE.	2	For changes to the UNSTABLE branch, see ChangeLog-UNSTABLE.
		3	Version 1.8.2d
		4	--------------
		5	*New in 1.8.2d
		6	*ADDED: Dynamic Partfiles (named as x.pnew and x.pnew.met instead of x.part and x.part.met)
		7	This type of partfiles needs only as much space on disk as downloaded, not as the filesize tells
		8	Its possible, to use both types with the some xmule at the same time (to finish older downloads)
		9	*ADDED: Renewable Clienthash on startup (to increase security) (to activate look at FlowChart
		10	*ADDED: Configureoption "--enable-cryptopp" to use the original library instead of the far more
		11	compact CryptoXMpp for compatibility reasons (on 64-Bitsystems and other than i386).
		12	*Bugfixes
		13	*FIXED: Corrected version-information for xmule (Thanks to Kry from aMule team to inform us
		14	about that!) for CT_VERSION_MOD on SendHelloTypePacket in BaseClient.cpp.
		15	*FIXED: Clienthash now saved and loaded
		16
3	Version 1.8.2c	17	Version 1.8.2c
4	--------------	18	--------------
5	2004-06-01	19	2004-06-01

Lines 56-58 Link Here

(-)xmule/INSTALL (+190 lines)
56	Otherwise, you will miss some popup-menues inside the FlowChart-Window, which are needed to enable functions	56	Otherwise, you will miss some popup-menues inside the FlowChart-Window, which are needed to enable functions
57	like "source-exchange" and "securehash/ident/creditfiles".	57	like "source-exchange" and "securehash/ident/creditfiles".
58		58
		59	===========================================================================================================
		60	NEW: Overview to install all needed libs from scratch under problematic conditions (suse/mandrake/fc2/etc):
		61	=========================================english===========================================================
		62	You will need:
		63
		64	autoconf-2.59 (min. see autoconf --version)
		65	gettext-0.11.5 (min. see gettext --version)
		66	automake-1.7.9 (min. see automake --version)
		67	glib-1.2.10
		68	gtk-1.2.10
		69	wxGTK-2.4.2 (no unicode, to configure with --with-gtk
		70	--disable-gtk2)
		71	xMule-1.8.2c
		72
		73
		74	To download:
		75
		76	cd /usr/src
		77	wget ftp://ftp.gnu.org/gnu/autoconf/autoconf-2.59.tar.gz
		78	wget ftp://ftp.gnu.org/gnu/gettext/gettext-0.11.5.tar.gz
		79	wget ftp://ftp.gnu.org/gnu/automake/automake-1.7.9.tar.gz
		80	wget ftp://ftp.nctu.edu.tw/UNIX/gtk/v1.2/glib-1.2.10.tar.gz
		81	wget ftp://ftp.nctu.edu.tw/UNIX/gtk/v1.2/gtk+-1.2.10.tar.gz
		82	wget
		83	http://heanet.dl.sourceforge.net/sourceforge/wxwindows/wxGTK-2.4.2.tar.gz
		84	wget http://download.gna.org/xmule/xmule-1.8.2c.tar.gz
		85
		86	To install:
		87
		88	cd /usr/src
		89	tar zxvf autoconf*.gz
		90	tar zxvf gettext*.gz
		91	tar zxvf automake*.gz
		92	tar zxvf glib*.gz
		93	tar zxvf gtk*.gz
		94	tar zxvf wxGTK*.gz
		95	tar zxvf xmule*.gz
		96
		97	cd /usr/src/autoconf*9
		98	./configure
		99	make
		100	make install
		101
		102	cd /usr/src/gettext*5
		103	./configure
		104	make
		105	make install
		106
		107	cd /usr/src/automake*9
		108	./configure
		109	make
		110	make install
		111
		112	vi /etc/ld.so.conf
		113	>>>>insert the following lines if not exist:
		114	/usr/local/lib
		115	/usr/local/lib/glib-1.2
		116	/usr/local/lib/gtk-1.2
		117
		118	cd /usr/src/glib*10
		119	./configure
		120	make
		121	make install
		122	ldconfig
123
124	cd /usr/src/gtk*10
125	./configure
126	make
127	make install
128	ldconfig
129
130	cd /usr/src/wxGTK*2
131	./configure --with-gtk --disable-gtk2
132	make
133	make install
134	ldconfig
135
136	cd /usr/src/xmule*2c
137	./configure --enable-debug
138	make
139	cp /usr/src/xmule*2c/src/xmule /usr/bin
140	chmod 755 /usr/bin/xmule
141
142	For every user-account ($HOME) you wish to use xMule, you
143	have to do the following:
144
145	mkdir $HOME/.xMule
146	chmod 777 $HOME/.xMule
147	cp -R /usr/src/xmule*2c/src/resource $HOME/.xMule
148	chmod 755 $HOME/.xMule/resource
149
150	That's all!
151	===========================================================================================================
152	NEW: Übersicht um alle benötigten Libraries zu installieren unter erschwerten Bedingungen/ohne Kentnisse:
153	=========================================deutsch===========================================================
154	Benötigt dazu werden nur (alle selbst zu kompilieren, in dieser Reihenfolge - in 30 Minuten erledigt):
155
156	autoconf-2.59 (mindestens, siehe autoconf --version)
157	gettext-0.11.5 (mindestens, siehe gettext --version)
158	automake-1.7.9 (mindestens, siehe automake --version)
159	glib-1.2.10
160	gtk-1.2.10
161	wxGTK-2.4.2 (kein Unicode, configured mit --with-gtk --disable-gtk2)
162	xMule-1.8.2c
163
164	Zur Vorbereitung:
165
166	Yast2 starten, Software installieren/deinstallieren, Suche:
167
168	glib -> eventuell installierte Pakete glib-1.2.10 & -devel löschen
169	gtk -> eventuell installierte Pakete gtk+-1.2.10 & -devel löschen
170	wxGTK-2.4.1 -> falls installiert, löschen
171
172	Yast2 verlassen.
173
174	Zum Download:
175
176	cd /usr/src
177	wget <ftp://ftp.gnu.org/gnu/autoconf/autoconf-2.59.tar.gz>
178	wget <ftp://ftp.gnu.org/gnu/gettext/gettext-0.11.5.tar.gz>
179	wget <ftp://ftp.gnu.org/gnu/automake/automake-1.7.9.tar.gz>
180	wget <ftp://ftp.nctu.edu.tw/UNIX/gtk/v1.2/glib-1.2.10.tar.gz>
181	wget <ftp://ftp.nctu.edu.tw/UNIX/gtk/v1.2/gtk+-1.2.10.tar.gz>
182	wget <http://heanet.dl.sourceforge.net/sourceforge/wxwindows/wxGTK-2.4.2.tar.gz>
183	wget <http://download.gna.org/xmule/xmule-1.8.2c.tar.gz>
184
185	Zur Installation:
186
187	cd /usr/src
188	tar zxvf autoconf*.gz
189	tar zxvf gettext*.gz
190	tar zxvf automake*.gz
191	tar zxvf glib*.gz
192	tar zxvf gtk*.gz
193	tar zxvf wxGTK*.gz
194	tar zxvf xmule*.gz
195
196	cd /usr/src/autoconf*9
197	./configure
198	make
199	make install
200
201	cd /usr/src/gettext*5
202	./configure
203	make
204	make install
205
206	cd /usr/src/automake*9
207	./configure
208	make
209	make install
210
211	vi /etc/ld.so.conf
212	>>>>folgende Zeilen eintragen (falls keine solche vorhanden)
213	/usr/local/lib
214	/usr/local/lib/glib-1.2
215	/usr/local/lib/gtk-1.2
216
217	cd /usr/src/glib*10
218	./configure
219	make
220	make install
221	ldconfig
222
223	cd /usr/src/gtk*10
224	./configure
225	make
226	make install
227	ldconfig
228
229	cd /usr/src/wxGTK*2
230	./configure --with-gtk --disable-gtk2
231	make
232	make install
233	ldconfig
234
235	cd /usr/src/xmule*2c
236	./configure --enable-debug
237	make
238	cp /usr/src/xmule*2c/src/xmule /usr/bin
239	chmod 755 /usr/bin/xmule
240
241	Für jeden Benutzeraccount ($HOME) notwendig, für den man xMule verwenden möchte:
242
243	mkdir $HOME/.xMule
244	chmod 777 $HOME/.xMule
245	cp -R /usr/src/xmule*2c/src/resource $HOME/.xMule
246	chmod 755 $HOME/.xMule/resource
247
248	Das war alles!

Lines 1-10 Link Here

(-)xmule/TODO (-9 / +26 lines)
1	V1.8.0 TODO:	1	v1.8.x TODO:
2	------------	2	------------
3	DONE: Fixing Bug that Files <9mb are not downloadable	3	priority,status,info
4	DONE: Fixing UDP-Port CPU-idle Bug	4	1,open: new functions to convert partfiles from and to new-format
5	DONE: Fix the m4 file missing problem	5	1,open: serverless-runmode for xmule
6	DONE: Make listctrl events work with GTK2	6	2,open: priorities-bugfix & optimization for downloadtable
7	DONE: Changing Version Number to 1.8.0	7	3,open: xmule-icon-only instead of minimized in toolbar & icon at the same time
8	DONE: Only one file seems to download at a time, unless 2 files start downloading within 1 minute of each other.	8	3,open: encryption of partfiles and sharedfiles for only being decrypted while xmule is running with the
9	DONE:Fixing crashes caused by CClientReqSocket::ProcessPacket OP_EMULEINFOANSWER 02,76 and other	9	.......correct privatekey. publickey will be endless (for every byte/character enother encoding-base)
10		10	.......so only who knows the privatekey is able to decrypt the encrypted date and this only while xmule
		11	.......is running - so no further filesystem-encryption will be needed after xmule encrypted all files
		12	.......in itself on disk.
		13	.......the encrypted files could be burned to dvd or cd - the length of the files will be the same
		14	.......(encrypted or decrypted)
		15	.......encrypted files on dvd/cdr will be usable/accessible after an additional decryption over xmule to disk
		16	.......
		17	.......the private key will not be stored anywhere
		18	.......the private key will be the key to enter xmule in the future - everyone can define the privatekey for
		19	.......itself on every start. if the privatekey on start is another than on the last start of xmule,
		20	.......all files not encrypted with the actual privatekey will not be accessible/usable
		21	.......
		22	.......the encryption-algorithm will be a completely new one - never used before. so there will be no
		23	.......other program at the moment which will be able to decrypt the files encrypted by xmule other than
		24	.......xmule itself
		25	.......
		26	.......this means: you should never forget your privatekey, otherwise all files encrypted with this key
		27	...................will be lost forever

Lines 23-28 Link Here

(-)xmule/src/AddFileThread.cpp (-6 / +3 lines)
23	# include "KnownFile.h"	23	# include "KnownFile.h"
24	# include "opcodes.h"	24	# include "opcodes.h"
25	# include "otherfunctions.h"	25	# include "otherfunctions.h"
		26	# include "PartFile.h"
26	# include "types.h"	27	# include "types.h"
27	# include "xmule.h"	28	# include "xmule.h"
28	# include "xmuleDlg.h"	29	# include "xmuleDlg.h"
Lines 59-67 Link Here
59	void CAddFileThread:: Shutdown()	60	void CAddFileThread:: Shutdown()
60	{	61	{
61	m_lockWaitingForHashList.Lock();	62	m_lockWaitingForHashList.Lock();
62	#if defined(__DEBUG__)
63	printf("Signaling hashing thread to terminate\n");
64	#endif
65	// Tell the thread to exit	63	// Tell the thread to exit
66	m_endWaitingForHashList = 1;	64	m_endWaitingForHashList = 1;
67	// Signal the thread there is something to do	65	// Signal the thread there is something to do
Lines 101-109 Link Here
101	UnknownFile_Struct *hashfile = m_sWaitingForHashList.RemoveHead();	99	UnknownFile_Struct *hashfile = m_sWaitingForHashList.RemoveHead();
102	m_lockWaitingForHashList.Unlock();	100	m_lockWaitingForHashList.Unlock();
103	CKnownFile *newrecord = new CKnownFile();	101	CKnownFile *newrecord = new CKnownFile();
104	printf("Sharing %s/%s\n", hashfile -> directory, hashfile -> name);	102	newrecord -> CreateFromFile(hashfile->owner,hashfile -> directory, hashfile -> name,
105	// TODO: What we are supposed to do if the following does fail?	103	&m_endWaitingForHashList);
106	newrecord -> CreateFromFile(hashfile -> directory, hashfile -> name, &m_endWaitingForHashList);
107	if (!m_endWaitingForHashList)	104	if (!m_endWaitingForHashList)
108	{	105	{
109	wxCommandEvent evt(wxEVT_COMMAND_MENU_SELECTED, TM_FINISHEDHASHING);	106	wxCommandEvent evt(wxEVT_COMMAND_MENU_SELECTED, TM_FINISHEDHASHING);

Lines 26-37 Link Here

(-)xmule/src/ClientCredits.h (-3 / +3 lines)
26	#include "Preferences.h"	26	#include "Preferences.h"
27	#include "MapKey.h"	27	#include "MapKey.h"
28		28
29	#if 1	29	#ifdef __CRPP__
30	# include "CryptoXMpp.h"
31	#else
32	# include <cryptopp/cryptlib.h>	30	# include <cryptopp/cryptlib.h>
33	# include <cryptopp/rsa.h>	31	# include <cryptopp/rsa.h>
34	#define CryptoXMpp CryptoPP	32	#define CryptoXMpp CryptoPP
		33	#else
		34	# include "CryptoXMpp.h"
35	#endif	35	#endif
36		36
37	/* winemaker: #pragma pack(1) */	37	/* winemaker: #pragma pack(1) */

Lines 159-166 Link Here

(-)xmule/src/DownloadQueue.cpp (-2 / +8 lines)
159	wxFileName myFileName(fileName);	159	wxFileName myFileName(fileName);
160	printf("Loading %s... ", myFileName.GetFullName() .GetData());	160	printf("Loading %s... ", myFileName.GetFullName() .GetData());
161	CPartFile *toadd = new CPartFile();	161	CPartFile *toadd = new CPartFile();
162	if (toadd -> LoadPartFile(app_prefs -> GetTempDir(), (char *) myFileName.GetFullName() .GetData()))	162	if (toadd -> LoadPartFile(count0,app_prefs -> GetTempDir(), (char *) myFileName.GetFullName() .GetData()))
163	{	163	{
		164	switch(count0) {
		165	case 0:
		166	toadd->SetIsDynamic(false);break;
		167	case 1:
		168	toadd->SetIsDynamic(true);break;
		169	}
164	count++;	170	count++;
165	printf("Done.\n");	171	printf("Done.\n");
166	filelist.AddTail(toadd);	172	filelist.AddTail(toadd);
Lines 980-986 Link Here
980	cur_file -> PauseFile();	986	cur_file -> PauseFile();
981	break;	987	break;
982	case MP_STOP:	988	case MP_STOP:
983	cur_file -> StopFile();	989	cur_file -> StopFile(0);
984	break;	990	break;
985	case MP_RESUME:	991	case MP_RESUME:
986	if (cur_file -> GetStatus() == PS_PAUSED)	992	if (cur_file -> GetStatus() == PS_PAUSED)

Lines 108-114 Link Here

(-)xmule/src/KnownFile.h (-33 / +6 lines)
108	CKnownFile();	108	CKnownFile();
109	~CKnownFile();	109	~CKnownFile();
110		110
111	virtual bool CreateFromFile(char* directory,char* filename, volatile int const * notify); // create date, hashset and tags from a file	111	virtual bool CreateFromFile(void* pf,char* directory,char* filename, volatile int const * notify); // create date, hashset and tags from a file
112	uint32* GetFileTypePtr() {return &m_iFileType;}	112	uint32* GetFileTypePtr() {return &m_iFileType;}
113	char* GetPath() {return directory;}	113	char* GetPath() {return directory;}
114	void SetPath(char* path);	114	void SetPath(char* path);
Lines 154-169 Link Here
154	protected:	154	protected:
155	bool LoadTagsFromFile(CFile* file);	155	bool LoadTagsFromFile(CFile* file);
156	bool LoadDateFromFile(CFile* file);	156	bool LoadDateFromFile(CFile* file);
157	void CreateHashFromFile(FILE* file, int Length, uchar* Output) {CreateHashFromInput(file,0,Length,Output,0);}	157	void CreateHashFromFile(FILE* file, int Length, uchar* Output);
158	void CreateHashFromFile(CFile* file, int Length, uchar* Output) {CreateHashFromInput(0,file,Length,Output,0);}	158	void CreateHashFromString(uchar* in_string, int Length, uchar* Output) {CreateHashFromInput(0,0,0,Length,Output,in_string);}
159	void CreateHashFromString(uchar* in_string, int Length, uchar* Output) {CreateHashFromInput(0,0,Length,Output,in_string);}
160	void LoadComment();//comment	159	void LoadComment();//comment
161	CArray<uchar,uchar> hashlist;	160	CArray<uchar,uchar> hashlist;
162	CArray<CTag,CTag> taglist;	161	CArray<CTag,CTag> taglist;
163	char* directory;	162	char* directory;
164		163
165	private:	164	private:
166	void CreateHashFromInput(FILE* file,CFile* file2, int Length, uchar* Output, uchar* = 0);	165	void CreateHashFromInput(int id,FILE* file,CFile* file2, int Length, uchar* Output, uchar* = 0);
167	bool m_bCommentLoaded;	166	bool m_bCommentLoaded;
168	uint16 m_iPartCount;	167	uint16 m_iPartCount;
169	uint16 m_iED2KPartCount;	168	uint16 m_iED2KPartCount;
Lines 174-179 Link Here
174	uint32 m_iQueuedCount;	173	uint32 m_iQueuedCount;
175	static CBarShader s_ShareStatusBar;	174	static CBarShader s_ShareStatusBar;
176	bool m_PublishedED2K;	175	bool m_PublishedED2K;
		176	int m_isDynamic;
		177	long m_hfilepos;
177		178
178	public:	179	public:
179	time_t m_nCompleteSourcesTime;	180	time_t m_nCompleteSourcesTime;
Lines 191-222 Link Here
191	#define PERM_NOONE 2	192	#define PERM_NOONE 2
192		193
193		194
194	// basic MD4 functions
195	#define MD4_F(x, y, z) (((x) & (y)) \| ((~x) & (z)))
196	#define MD4_G(x, y, z) (((x) & (y)) \| ((x) & (z)) \| ((y) & (z)))
197	#define MD4_H(x, y, z) ((x) ^ (y) ^ (z))
198
199	// rotates x left n bits
200	#define MD4_ROTATE_LEFT(x, n) (((x) << (n)) \| ((x) >> (32-(n))))
201
202	// partial transformations
203	#define MD4_FF(a, b, c, d, x, s) \
204	{ \
205	(a) += MD4_F((b), (c), (d)) + (x); \
206	(a) = MD4_ROTATE_LEFT((a), (s)); \
207	}
208
209	#define MD4_GG(a, b, c, d, x, s) \
210	{ \
211	(a) += MD4_G((b), (c), (d)) + (x) + (uint32)0x5A827999; \
212	(a) = MD4_ROTATE_LEFT((a), (s)); \
213	}
214
215	#define MD4_HH(a, b, c, d, x, s) \
216	{ \
217	(a) += MD4_H((b), (c), (d)) + (x) + (uint32)0x6ED9EBA1; \
218	(a) = MD4_ROTATE_LEFT((a), (s)); \
219	}
220
221
222	#endif	195	#endif

Lines 24-29 Link Here

(-)xmule/src/NewFunctions.h (+29 lines)
24		24
25	#define MAPCLIENTS_MAX 30000	25	#define MAPCLIENTS_MAX 30000
26		26
		27	// basic MD4 functions
		28	#define MD4_F(x, y, z) (((x) & (y)) \| ((~x) & (z)))
		29	#define MD4_G(x, y, z) (((x) & (y)) \| ((x) & (z)) \| ((y) & (z)))
		30	#define MD4_H(x, y, z) ((x) ^ (y) ^ (z))
		31
		32	// rotates x left n bits
		33	#define MD4_ROTATE_LEFT(x, n) (((x) << (n)) \| ((x) >> (32-(n))))
		34
		35	// partial transformations
		36	#define MD4_FF(a, b, c, d, x, s) \
		37	{ \
		38	(a) += MD4_F((b), (c), (d)) + (x); \
		39	(a) = MD4_ROTATE_LEFT((a), (s)); \
		40	}
		41
		42	#define MD4_GG(a, b, c, d, x, s) \
		43	{ \
		44	(a) += MD4_G((b), (c), (d)) + (x) + (uint32)0x5A827999; \
		45	(a) = MD4_ROTATE_LEFT((a), (s)); \
		46	}
		47
		48	#define MD4_HH(a, b, c, d, x, s) \
		49	{ \
		50	(a) += MD4_H((b), (c), (d)) + (x) + (uint32)0x6ED9EBA1; \
		51	(a) = MD4_ROTATE_LEFT((a), (s)); \
		52	}
		53	void MD4Transform(uint32 Hash[4],uint32 x[16]);
		54	void md4printf(const void *hash);
		55
27	typedef struct _MAP	56	typedef struct _MAP
28	{	57	{
29	_MAP* next;	58	_MAP* next;

Lines 41-46 Link Here

(-)xmule/src/Preferences.cpp (-113 / +139 lines)
41	#else	41	#else
42	# include "wintypes.h"	42	# include "wintypes.h"
43	# include "Preferences.h"	43	# include "Preferences.h"
		44	# include "FlowChart.h"
		45	# include "NewFunctions.h"
44	# include "opcodes.h"	46	# include "opcodes.h"
45	# include "otherfunctions.h"	47	# include "otherfunctions.h"
46	# include "ini2.h"	48	# include "ini2.h"
Lines 71-112 Link Here
71	#endif	73	#endif
72		74
73	#ifdef __FreeBSD__	75	#ifdef __FreeBSD__
74	extern long long atoll(char *s);	76	extern long long atoll(char * s);
75	#endif /* __FreeBSD__ */	77	#endif /* __FreeBSD__ */
76		78
		79	extern wxString newprefs01_alpha[];
77		80
78		81	CPreferences::CPreferences()
79	CPreferences:: CPreferences()
80	{	82	{
81	// we need random numbers sometimes:	83	// we need random numbers sometimes:
82	srand((uint32) time(0));	84	srand((uint32) time(0));
83	// Define prefs	85	// Define prefs
84	prefs = new Preferences_Struct;	86	prefs = new Preferences_Struct;
85	memset(prefs, 0, sizeof(Preferences_Struct));	87	memset(prefs, 0, sizeof(Preferences_Struct));
86	prefsExt = new Preferences_Ext_Struct;
87	memset(prefsExt, 0, sizeof(Preferences_Ext_Struct));
88	// Use home directory to save preferences	88	// Use home directory to save preferences
89	char buffer[490];	89	char buffer[490];
90	snprintf(buffer, 400, "%s/." PACKAGE_NAME, getenv("HOME"));	90	snprintf(buffer, 400, "%s/." PACKAGE_NAME, getenv("HOME"));
91	mkdir(buffer, 0777);	91	mkdir(buffer, 0777);
92	strncat(buffer, "/", 1);	92	strncat(buffer, "/", 1);
93	SetAppDir(nstrdup(buffer));	93	SetAppDir(nstrdup(buffer));
94	// Create UserHash	94	if(newprefs01_opt[7]) {
95	CreateUserHash();	95	newprefs01_alpha[7]="";
96	md4cpy( &prefs->userhash, &userhash);
97	if (((int ) prefs -> userhash) [0] == 0 && ((int ) prefs -> userhash) [1] == 0 && ((int ) prefs -> userhash) [2] == 0 && ((int ) prefs -> userhash) [3] == 0)
98	{
99	CreateUserHash();
100	}	96	}
101	// Load Preferences	97	CreateUserHash();
		98	md4cpy( & prefs -> userhash, & userhash);
102	Load(true);	99	Load(true);
103	// ???
104	prefs -> m_bUseSecureIdent = true;	100	prefs -> m_bUseSecureIdent = true;
105	}	101	}
106		102
107	CPreferences:: ~CPreferences()	103	CPreferences::~ CPreferences()
108	{	104	{
109	Category_Struct *delcat;	105	Category_Struct * delcat;
110	while (!catMap.IsEmpty())	106	while (!catMap.IsEmpty())
111	{	107	{
112	delcat = catMap.GetAt(0);	108	delcat = catMap.GetAt(0);
Lines 114-128 Link Here
114	delete delcat;	110	delete delcat;
115	}	111	}
116	delete prefs;	112	delete prefs;
117	delete prefsExt;
118	}	113	}
119		114
120		115	void CPreferences::SetStandartValues()
121	void CPreferences:: SetStandartValues()
122	{	116	{
123	wxString buffer;	117	wxString buffer;
		118	newprefs01_alpha[7]="";
124	CreateUserHash();	119	CreateUserHash();
125	md4cpy( &prefs -> userhash, &userhash);	120	md4cpy( & prefs -> userhash, & userhash);
126	WINDOWPLACEMENT defaultWPM;	121	WINDOWPLACEMENT defaultWPM;
127	defaultWPM.length = sizeof(WINDOWPLACEMENT);	122	defaultWPM.length = sizeof(WINDOWPLACEMENT);
128	defaultWPM.rcNormalPosition.left = 10;	123	defaultWPM.rcNormalPosition.left = 10;
Lines 134-149 Link Here
134	prefs -> versioncheckLastAutomatic = 0;	129	prefs -> versioncheckLastAutomatic = 0;
135	}	130	}
136		131
137	bool CPreferences:: Load(bool startup)	132	bool CPreferences::Load(bool startup)
138	{	133	{
139	bool error = false;	134	bool error = false;
140	if(LoadPreferences())	135	if (LoadPreferences())
141	{	136	{
142	if(startup)	137	if (startup)
143	{	138	{
144	//Can't find Preferences file, but in LoadPreferences() the standard was defined. Now we have to save it.	139	//Can't find Preferences file, but in LoadPreferences() the standard was defined. Now we have to save it.
145	SetStandartValues();	140	SetStandartValues();
146	if(Save(1))	141	if (Save(1))
147	{	142	{
148	error = true;	143	error = true;
149	}	144	}
Lines 156-203 Link Here
156	}	151	}
157	if (startup)	152	if (startup)
158	{	153	{
159	if(LoadCats())	154	if (LoadCats())
160	{	155	{
161	//Catfile don't exist, let's create one	156	//Catfile don't exist, let's create one
162	if(Save(2))	157	if (Save(2))
163	{	158	{
164	error = true;	159	error = true;
165	}	160	}
166	}	161	}
167	if(Load_Shared_Dirs())	162	if (Load_Shared_Dirs())
168	{	163	{;
169	; //Maybe the User has not shared dirs	164	//Maybe the User has not shared dirs
170	}	165	}
171	if(Load_Adresses())	166	if (Load_Adresses())
172	{	167	{;
173	; //And also no Adresslist	168	//And also no Adresslist
174	}	169	}
175	}	170	}
176	return error;	171	return error;
177	}	172	}
178		173
179	bool CPreferences:: Save(unsigned char selection_mask)	174	bool CPreferences::Save(unsigned char selection_mask)
180	{	175	{
181	bool error = false;	176	bool error = false;
182	if (selection_mask &1)	177	if (selection_mask & 1)
183	{	178	{
184	SavePreferences();	179	SavePreferences();
185	}	180	}
186	if (selection_mask &2)	181	if (selection_mask & 2)
187	{	182	{
188	if (SaveCats())	183	if (SaveCats())
189	{	184	{
190	error = true;	185	error = true;
191	}	186	}
192	}	187	}
193	if (selection_mask &4)	188	if (selection_mask & 4)
194	{	189	{
195	if (Save_Shared_Dirs())	190	if (Save_Shared_Dirs())
196	{	191	{
197	error = true;	192	error = true;
198	}	193	}
199	}	194	}
200	if (selection_mask &8)	195	if (selection_mask & 8)
201	{	196	{
202	if (Save_Adresses())	197	if (Save_Adresses())
203	{	198	{
Lines 207-227 Link Here
207	return error;	202	return error;
208	}	203	}
209		204
210	void CPreferences:: CreateUserHash()	205	void CPreferences::CreateUserHash()
211	{	206	{
		207	if (newprefs01_alpha[7].Len() != 32)
		208	{
212	for (int i = 0 ; i != 8 ; i++)	209	for (int i = 0 ; i != 8 ; i++)
213	{	210	{
214	uint16 random = rand();	211	uint16 random = rand();
215	memcpy( &userhash[i*2], &random, 2);	212	memcpy( & userhash[i * 2], & random, 2);
216	}	213	}
217	// mark as emule client. that will be need in later version	214	// mark as emule client. that will be need in later version
218	userhash[5] = 14;	215	userhash[5] = 14;
219	userhash[14] = 111;	216	userhash[14] = 111;
		217	newprefs01_alpha[7] ="";
		218	for (int i = 0 ; i < 16 ; i++)
		219	{
		220	newprefs01_alpha[7] += wxString:: Format("%02x", (unsigned char) userhash[i]);
		221	}
		222	}
		223	else
		224	{
		225	unsigned char c;
		226	for (int i = 0 ; i < 32 ; i++)
		227	{
		228	c =((unsigned char)(const char ) newprefs01_alpha[7])[i];
		229	if (c >= '0' && c <= '9')
		230	{
		231	c -= '0';
		232	}
		233	else if(c >= 'a' && c <= 'f')
		234	{
		235	c -= 'a' - 10;
		236	}
		237	else if(c >= 'A' && c <= 'F')
		238	{
		239	c -='A' - 10;
		240	}
		241	if (i&1)
		242	{
		243	userhash[i>>1] = (userhash[i>>1] << 4) \| c;
		244	}
		245	else
		246	{
		247	userhash[i>>1] = c;
		248	}
		249	}
		250	}
220	}	251	}
221		252
222	int CPreferences:: GetRecommendedMaxConnections()	253	int CPreferences::GetRecommendedMaxConnections()
223	{	254	{
224	int iRealMax =:: GetMaxConnections();	255	int iRealMax =::GetMaxConnections();
225	if (iRealMax == - 1 \|\| iRealMax > 520)	256	if (iRealMax == - 1 \|\| iRealMax > 520)
226	return 500;	257	return 500;
227	if (iRealMax < 20)	258	if (iRealMax < 20)
Lines 231-237 Link Here
231	return iRealMax - 20;	262	return iRealMax - 20;
232	}	263	}
233		264
234	WORD CPreferences:: GetWindowsVersion()	265	WORD CPreferences::GetWindowsVersion()
235	{	266	{
236	static bool bWinVerAlreadyDetected = false;	267	static bool bWinVerAlreadyDetected = false;
237	if (!bWinVerAlreadyDetected)	268	if (!bWinVerAlreadyDetected)
Lines 242-254 Link Here
242	return m_wWinVer;	273	return m_wWinVer;
243	}	274	}
244		275
245	uint16 CPreferences:: GetDefaultMaxConperFive()	276	uint16 CPreferences::GetDefaultMaxConperFive()
246	{	277	{
247	return MAXCONPER5SEC;	278	return MAXCONPER5SEC;
248	}	279	}
249		280
250		281	void CPreferences::ResetStatsColor(int index)
251	void CPreferences:: ResetStatsColor(int index)
252	{	282	{
253	switch (index)	283	switch (index)
254	{	284	{
Lines 272-292 Link Here
272	break;	302	break;
273	case 9: prefs -> statcolors[9] = RGB(192, 0, 192);	303	case 9: prefs -> statcolors[9] = RGB(192, 0, 192);
274	break;	304	break;
275	case 10:prefs -> statcolors[10] = RGB(255, 255, 128);	305	case 10: prefs -> statcolors[10] = RGB(255, 255, 128);
276	break;	306	break;
277	case 11:prefs -> statcolors[11] = RGB(0, 0, 0);	307	case 11: prefs -> statcolors[11] = RGB(0, 0, 0);
278	break;	308	break;
279	case 12:prefs -> statcolors[12] = RGB(255, 255, 255);	309	case 12: prefs -> statcolors[12] = RGB(255, 255, 255);
280	break;	310	break;
281	default:break;	311	default: break;
282	}	312	}
283	}	313	}
284		314
285	void CPreferences:: SavePreferences(void)	315	void CPreferences::SavePreferences(void)
286	{	316	{
287	CString buffer;	317	CString buffer;
288	CString buffer2;	318	CString buffer2;
289	char *full_path = new char[strlen(getenv("HOME")) + 2];	319	char * full_path = new char[strlen(getenv("HOME")) + 2];
290	sprintf(full_path, "%s/", getenv("HOME"));	320	sprintf(full_path, "%s/", getenv("HOME"));
291	CIni ini(full_path, "eMule");	321	CIni ini(full_path, "eMule");
292	ini.WriteString("AppVersion", PACKAGE_STRING);	322	ini.WriteString("AppVersion", PACKAGE_STRING);
Lines 468-485 Link Here
468	ini.WriteInt("AutoDropTimer", prefs -> AutoDropTimer);	498	ini.WriteInt("AutoDropTimer", prefs -> AutoDropTimer);
469	}	499	}
470		500
471	bool CPreferences:: LoadPreferences(void)	501	bool CPreferences::LoadPreferences(void)
472	{	502	{
473	bool error = false;	503	bool error = false;
474	bool NoColor = true;	504	bool NoColor = true;
475	CString buffer2;	505	CString buffer2;
476	char buffer[200];	506	char buffer[200];
477	//Open File for Test	507	//Open File for Test
478	char *full_path = new char[strlen(getenv("HOME")) + 2];	508	char * full_path = new char[strlen(getenv("HOME")) + 2];
479	sprintf(full_path, "%s/", getenv("HOME"));	509	sprintf(full_path, "%s/", getenv("HOME"));
480	char *test_file = new char[strlen(full_path) + 7];	510	char * test_file = new char[strlen(full_path) + 7];
481	sprintf(test_file, "%s.eMule", full_path);	511	sprintf(test_file, "%s.eMule", full_path);
482	FILE *testfile = fopen(test_file, "r");	512	FILE * testfile = fopen(test_file, "r");
483	if (!testfile)	513	if (!testfile)
484	{	514	{
485	error = true;	515	error = true;
Lines 680-692 Link Here
680	return error;	710	return error;
681	}	711	}
682		712
683	bool CPreferences:: Load_Adresses(void)	713	bool CPreferences::Load_Adresses(void)
684	{	714	{
685	//serverlist adresses	715	//serverlist adresses
686	bool error = false;	716	bool error = false;
687	char *full_path = new char[strlen(GetAppDir()) + 13];	717	char * full_path = new char[strlen(GetAppDir()) + 13];
688	sprintf(full_path, "%sadresses.dat", GetAppDir());	718	sprintf(full_path, "%sadresses.dat", GetAppDir());
689	FILE *sdirfile = fopen(full_path, "r");	719	FILE * sdirfile = fopen(full_path, "r");
690	if (sdirfile)	720	if (sdirfile)
691	{	721	{
692	char buffer[MAX_PATH];	722	char buffer[MAX_PATH];
Lines 694-701 Link Here
694	{	724	{
695	memset(buffer, 0, sizeof(buffer));	725	memset(buffer, 0, sizeof(buffer));
696	fgets(buffer, sizeof(buffer) - 1, sdirfile);	726	fgets(buffer, sizeof(buffer) - 1, sdirfile);
697	char *ptr = strchr(buffer, '\n');	727	char * ptr = strchr(buffer, '\n');
698	if (ptr) *ptr = 0;	728	if (ptr) * ptr = 0;
699	if (strlen(buffer) > 1)	729	if (strlen(buffer) > 1)
700	adresses_list.Append(new CString(buffer));	730	adresses_list.Append(new CString(buffer));
701	}	731	}
Lines 708-726 Link Here
708	return error;	738	return error;
709	}	739	}
710		740
711	bool CPreferences:: Save_Adresses(void)	741	bool CPreferences::Save_Adresses(void)
712	{	742	{
713	bool error = false;	743	bool error = false;;
714	; // I am to lazy atm :)	744	// I am to lazy atm :)
715	return error;	745	return error;
716	}	746	}
717		747
718	bool CPreferences:: Load_Shared_Dirs(void)	748	bool CPreferences::Load_Shared_Dirs(void)
719	{	749	{
720	bool error;	750	bool error;
721	char *full_path = new char[strlen(GetAppDir()) + 14];	751	char * full_path = new char[strlen(GetAppDir()) + 14];
722	sprintf(full_path, "%sshareddir.dat", GetAppDir());	752	sprintf(full_path, "%sshareddir.dat", GetAppDir());
723	FILE *sdirfile = fopen(full_path, "r");	753	FILE * sdirfile = fopen(full_path, "r");
724	if (sdirfile)	754	if (sdirfile)
725	{	755	{
726	char buffer[MAX_PATH];	756	char buffer[MAX_PATH];
Lines 728-735 Link Here
728	{	758	{
729	memset(buffer, 0, sizeof(buffer));	759	memset(buffer, 0, sizeof(buffer));
730	fgets(buffer, sizeof(buffer) - 1, sdirfile);	760	fgets(buffer, sizeof(buffer) - 1, sdirfile);
731	char *ptr = strchr(buffer, '\n');	761	char * ptr = strchr(buffer, '\n');
732	if (ptr) *ptr = 0;	762	if (ptr) * ptr = 0;
733	if (strlen(buffer) > 1)	763	if (strlen(buffer) > 1)
734	shareddir_list.Add(buffer);	764	shareddir_list.Add(buffer);
735	}	765	}
Lines 742-753 Link Here
742	return error;	772	return error;
743	}	773	}
744		774
745	bool CPreferences:: Save_Shared_Dirs(void)	775	bool CPreferences::Save_Shared_Dirs(void)
746	{	776	{
747	bool error = false;	777	bool error = false;
748	char *full_path = new char[strlen(GetAppDir()) + 14];	778	char * full_path = new char[strlen(GetAppDir()) + 14];
749	sprintf(full_path, "%sshareddir.dat", GetAppDir());	779	sprintf(full_path, "%sshareddir.dat", GetAppDir());
750	FILE *sdirfile = fopen(full_path, "w");	780	FILE * sdirfile = fopen(full_path, "w");
751	if (sdirfile)	781	if (sdirfile)
752	{	782	{
753	for (int i = 0 ; i < shareddir_list.GetCount() ; i++)	783	for (int i = 0 ; i < shareddir_list.GetCount() ; i++)
Lines 763-773 Link Here
763	return error;	793	return error;
764	}	794	}
765		795
766		796	bool CPreferences::SaveCats(void)
767	bool CPreferences:: SaveCats(void)
768	{	797	{
769	bool error = false;	798	bool error = false;
770	FILE *category_fd;	799	FILE * category_fd;
771	wxString catinif, buffer;	800	wxString catinif, buffer;
772	catinif.Printf("%sCategory.dat", GetAppDir());	801	catinif.Printf("%sCategory.dat", GetAppDir());
773	if (GetCatCount() > 0)	802	if (GetCatCount() > 0)
Lines 778-788 Link Here
778	fprintf(category_fd, "%d ", catMap.GetCount() - 1);	807	fprintf(category_fd, "%d ", catMap.GetCount() - 1);
779	for (int ix = 1 ; ix < catMap.GetCount() ; ix++)	808	for (int ix = 1 ; ix < catMap.GetCount() ; ix++)
780	{	809	{
781	fprintf(category_fd,"%s\n",catMap.GetAt(ix) -> title);	810	fprintf(category_fd, "%s\n", catMap.GetAt(ix) -> title);
782	fprintf(category_fd,"%s\n",catMap.GetAt(ix) -> incomingpath);	811	fprintf(category_fd, "%s\n", catMap.GetAt(ix) -> incomingpath);
783	fprintf(category_fd,"%s\n",catMap.GetAt(ix) -> comment);	812	fprintf(category_fd, "%s\n", catMap.GetAt(ix) -> comment);
784	fprintf(category_fd,"0x%lx\n", catMap.GetAt(ix)->color);	813	fprintf(category_fd, "0x%lx\n", catMap.GetAt(ix) -> color);
785	fprintf(category_fd,"%.3u\n", catMap.GetAt(ix)->prio + 1);	814	fprintf(category_fd, "%.3u\n", catMap.GetAt(ix) -> prio + 1);
786	}	815	}
787	fclose(category_fd);	816	fclose(category_fd);
788	}	817	}
Lines 794-812 Link Here
794	return error;	823	return error;
795	}	824	}
796		825
797	bool CPreferences:: LoadCats(void)	826	bool CPreferences::LoadCats(void)
798	{	827	{
799	bool error = false;	828	bool error = false;
800	int max;	829	int max;
801	wxString catinif;	830	wxString catinif;
802	char buffer[2051];	831	char buffer[2051];
803	char *dummy;	832	char * dummy;
804	FILE *category_fd;	833	FILE * category_fd;
805	// default cat	834	// default cat
806	Category_Struct *newcat = new Category_Struct;	835	Category_Struct * newcat = new Category_Struct;
807	sprintf(newcat->title, "");	836	sprintf(newcat -> title, "");
808	sprintf(newcat->incomingpath, "");	837	sprintf(newcat -> incomingpath, "");
809	sprintf(newcat->comment, "");	838	sprintf(newcat -> comment, "");
810	newcat -> prio = 0;	839	newcat -> prio = 0;
811	newcat -> color = 0;	840	newcat -> color = 0;
812	AddCat(newcat);	841	AddCat(newcat);
Lines 815-839 Link Here
815	category_fd = fopen(catinif, "r");	844	category_fd = fopen(catinif, "r");
816	if (category_fd != NULL)	845	if (category_fd != NULL)
817	{	846	{
818	fscanf(category_fd, "%d ", &max);	847	fscanf(category_fd, "%d ", & max);
819	for (int i = 1 ; i <= max ; i++)	848	for (int i = 1 ; i <= max ; i++)
820	{	849	{
821	Category_Struct *newcat = new Category_Struct;	850	Category_Struct * newcat = new Category_Struct;
822	fgets(buffer, 66, category_fd);	851	fgets(buffer, 66, category_fd);
823	sprintf(newcat->title, "");	852	sprintf(newcat -> title, "");
824	strncat(newcat->title, buffer, strlen(buffer) - 1);	853	strncat(newcat -> title, buffer, strlen(buffer) - 1);
825	fgets(buffer, 2050, category_fd);	854	fgets(buffer, 2050, category_fd);
826	sprintf(newcat->incomingpath, "");	855	sprintf(newcat -> incomingpath, "");
827	strncat(newcat->incomingpath, buffer, strlen(buffer) - 1);	856	strncat(newcat -> incomingpath, buffer, strlen(buffer) - 1);
828	fgets(buffer, 258, category_fd);	857	fgets(buffer, 258, category_fd);
829	sprintf(newcat->comment, "");	858	sprintf(newcat -> comment, "");
830	strncat(newcat->comment, buffer, strlen(buffer) - 1);	859	strncat(newcat -> comment, buffer, strlen(buffer) - 1);
831	fgets(buffer, 15, category_fd);	860	fgets(buffer, 15, category_fd);
832	newcat->color = (uint32)strtoul(buffer, &dummy, 0);	861	newcat -> color = (uint32) strtoul(buffer, & dummy, 0);
833	fgets(buffer, 5, category_fd);	862	fgets(buffer, 5, category_fd);
834	newcat->prio = (uint8) atoi(buffer) - 1;	863	newcat -> prio = (uint8) atoi(buffer) - 1;
835	AddCat(newcat);	864	AddCat(newcat);
836	if (!wxFileName:: DirExists(newcat -> incomingpath))	865	if (!wxFileName::DirExists(newcat -> incomingpath))
837	{	866	{
838	mkdir(newcat -> incomingpath, 0777);	867	mkdir(newcat -> incomingpath, 0777);
839	}	868	}
Lines 847-866 Link Here
847	return error;	876	return error;
848	}	877	}
849		878
850	void CPreferences:: RemoveCat(int index)	879	void CPreferences::RemoveCat(int index)
851	{	880	{
852	if (index >= 0 &&index < catMap.GetCount())	881	if (index >= 0 && index < catMap.GetCount())
853	{	882	{
854	Category_Struct *delcat;	883	Category_Struct * delcat;
855	delcat = catMap.GetAt(index);	884	delcat = catMap.GetAt(index);
856	catMap.RemoveAt(index);	885	catMap.RemoveAt(index);
857	delete delcat;	886	delete delcat;
858	}	887	}
859	}	888	}
860		889
861	int CPreferences:: GetColumnSortItem(Table t) const	890	int CPreferences::GetColumnSortItem(Table t) const
862	{	891	{
863
864	switch (t)	892	switch (t)
865	{	893	{
866	case tableDownload:	894	case tableDownload:
Lines 881-887 Link Here
881	return 0;	909	return 0;
882	}	910	}
883		911
884	bool CPreferences:: GetColumnSortAscending(Table t) const	912	bool CPreferences::GetColumnSortAscending(Table t) const
885	{	913	{
886	switch (t)	914	switch (t)
887	{	915	{
Lines 901-910 Link Here
901	return prefs -> tableSortAscendingClientList;	929	return prefs -> tableSortAscendingClientList;
902	}	930	}
903	return true;	931	return true;
904
905	}	932	}
906		933
907	void CPreferences:: SetColumnSortItem(Table t, int sortItem)	934	void CPreferences::SetColumnSortItem(Table t, int sortItem)
908	{	935	{
909	switch (t)	936	switch (t)
910	{	937	{
Lines 932-938 Link Here
932	}	959	}
933	}	960	}
934		961
935	void CPreferences:: SetColumnSortAscending(Table t, bool sortAscending)	962	void CPreferences::SetColumnSortAscending(Table t, bool sortAscending)
936	{	963	{
937	switch (t)	964	switch (t)
938	{	965	{
Lines 960-966 Link Here
960	}	987	}
961	}	988	}
962		989
963	int CPreferences:: GetColumnWidth(Table t, int index) const	990	int CPreferences::GetColumnWidth(Table t, int index) const
964	{	991	{
965	switch (t)	992	switch (t)
966	{	993	{
Lines 980-989 Link Here
980	return prefs -> clientListColumnWidths[index];	1007	return prefs -> clientListColumnWidths[index];
981	}	1008	}
982	return 0;	1009	return 0;
983
984	}	1010	}
985		1011
986	void CPreferences:: SetColumnWidth(Table t, int index, int width)	1012	void CPreferences::SetColumnWidth(Table t, int index, int width)
987	{	1013	{
988	switch (t)	1014	switch (t)
989	{	1015	{
Lines 1011-1017 Link Here
1011	}	1037	}
1012	}	1038	}
1013		1039
1014	BOOL CPreferences:: GetColumnHidden(Table t, int index) const	1040	BOOL CPreferences::GetColumnHidden(Table t, int index) const
1015	{	1041	{
1016	switch (t)	1042	switch (t)
1017	{	1043	{
Lines 1033-1039 Link Here
1033	return FALSE;	1059	return FALSE;
1034	}	1060	}
1035		1061
1036	void CPreferences:: SetColumnHidden(Table t, int index, BOOL bHidden)	1062	void CPreferences::SetColumnHidden(Table t, int index, BOOL bHidden)
1037	{	1063	{
1038	switch (t)	1064	switch (t)
1039	{	1065	{
Lines 1061-1067 Link Here
1061	}	1087	}
1062	}	1088	}
1063		1089
1064	int CPreferences:: GetColumnOrder(Table t, int index) const	1090	int CPreferences::GetColumnOrder(Table t, int index) const
1065	{	1091	{
1066	switch (t)	1092	switch (t)
1067	{	1093	{
Lines 1083-1089 Link Here
1083	return 0;	1109	return 0;
1084	}	1110	}
1085		1111
1086	void CPreferences:: SetColumnOrder(Table t, INT *piOrder)	1112	void CPreferences::SetColumnOrder(Table t, INT * piOrder)
1087	{	1113	{
1088	switch (t)	1114	switch (t)
1089	{	1115	{

Lines 42-58 Link Here

(-)xmule/src/Preferences.h (-12 lines)
42		42
43	#define DEFAULT_COL_SIZE 65535	43	#define DEFAULT_COL_SIZE 65535
44		44
45	// DO NOT EDIT VALUES like making a uint16 to uint32, or insert any value. ONLY append new vars
46	#pragma pack(1)
47	struct Preferences_Ext_Struct
48	{
49	int8 version;
50	uchar userhash[16];
51	WINDOWPLACEMENT EmuleWindowPlacement;
52	};
53
54	#pragma pack()
55
56	// deadlake PROXYSUPPORT	45	// deadlake PROXYSUPPORT
57	struct ProxySettings	46	struct ProxySettings
58	{	47	{
Lines 1388-1394 Link Here
1388	private:	1377	private:
1389	char appdir[MAX_PATH];	1378	char appdir[MAX_PATH];
1390	Preferences_Struct *prefs;	1379	Preferences_Struct *prefs;
1391	Preferences_Ext_Struct *prefsExt;
1392	char userhash[16];	1380	char userhash[16];
1393	WORD m_wWinVer;	1381	WORD m_wWinVer;
1394	CArray < Category_Struct , Category_Struct > catMap;	1382	CArray < Category_Struct , Category_Struct > catMap;

Lines 333-387 Link Here

(-)xmule/src/SharedFileList.cpp (-49 lines)
333	return - 10;	333	return - 10;
334	}	334	}
335		335
336	#if 0
337	CAddFileThread:: CAddFileThread(): wxThread(wxTHREAD_DETACHED)
338	{
339	}
340
341	wxThread:: ExitCode CAddFileThread:: Entry()
342	{
343	while (1)
344	{
345	g_lockWaitingForHashList.Lock();
346	if (g_endWaitingForHashList)
347	{
348	g_endedWaitingForHashList.Signal();
349	g_lockWaitingForHashList.Unlock();
350	return 0;
351	}
352	if (g_sWaitingForHashList.IsEmpty())
353	{
354	// Unlocks g_lockWaitingForHashList:
355	g_runWaitingForHashList.Wait();
356	g_lockWaitingForHashList.Unlock();
357	continue;
358	}
359	UnknownFile_Struct *hashfile = g_sWaitingForHashList.RemoveHead();
360	g_lockWaitingForHashList.Unlock();
361	CKnownFile *newrecord = new CKnownFile();
362	printf("Sharing %s/%s\n", hashfile -> directory, hashfile -> name);
363	newrecord -> CreateFromFile(hashfile -> directory, hashfile -> name);
364	g_lockWaitingForHashList.Lock();
365	if (g_endWaitingForHashList)
366	{
367	g_endedWaitingForHashList.Signal();
368	g_lockWaitingForHashList.Unlock();
369	return 0;
370	}
371	// TODO: Possible race condition between unlocking and wxPostEvent.
372	g_lockWaitingForHashList.Unlock();
373	wxCommandEvent evt(wxEVT_COMMAND_MENU_SELECTED, TM_FINISHEDHASHING);
374	evt.SetClientData(newrecord);
375	evt.SetInt((int) hashfile -> partfile_Owner);
376	wxPostEvent(theApp.xmuledlg, evt);
377	free(hashfile -> name);
378	free(hashfile -> directory);
379	delete hashfile;
380	}
381	}
382
383	#endif
384
385	void CSharedFileList:: UpdateItem(CKnownFile *toupdate)	336	void CSharedFileList:: UpdateItem(CKnownFile *toupdate)
386	{	337	{
387	output -> UpdateItem(toupdate);	338	output -> UpdateItem(toupdate);

Lines 87-98 Link Here

(-)xmule/src/TransferWnd.cpp (-423 lines)
87	{	87	{
88	}	88	}
89		89
90	#if 0
91	BEGIN_MESSAGE_MAP(CTransferWnd, CResizableDialog)
92	ON_NOTIFY_EX_RANGE(TTN_NEEDTEXT, 0, 0xFFFF, OnToolTipNotify)
93	END_MESSAGE_MAP()
94	#endif
95
96	BOOL CTransferWnd:: OnInitDialog()	90	BOOL CTransferWnd:: OnInitDialog()
97	{	91	{
98	m_dlTab = (CMuleNotebook *) FindWindowById(ID_CATEGORIES);	92	m_dlTab = (CMuleNotebook *) FindWindowById(ID_CATEGORIES);
Lines 109-152 Link Here
109	// but they will be accepted in SetPageText().. so let's use this as a countermeasure	103	// but they will be accepted in SetPageText().. so let's use this as a countermeasure
110	m_dlTab -> SetPageText(ix, tmpstrstr);	104	m_dlTab -> SetPageText(ix, tmpstrstr);
111	}	105	}
112	#if 0
113	CResizableDialog:: OnInitDialog();
114	Localize();
115	windowtransferstate = false;
116	uploadlistctrl.Init();
117	downloadlistctrl.Init();
118	queuelistctrl.Init();
119	((CStatic *) GetDlgItem(IDC_DOWNLOAD_ICO)) -> SetIcon((HICON):: LoadImage(AfxGetInstanceHandle(), MAKEINTRESOURCE(IDI_DIRECTDOWNLOAD), IMAGE_ICON, 16, 16, 0));
120	((CStatic *) GetDlgItem(IDC_UPLOAD_ICO)) -> SetIcon((HICON):: LoadImage(AfxGetInstanceHandle(), MAKEINTRESOURCE(IDI_UPLOAD), IMAGE_ICON, 16, 16, 0));
121	AddAnchor(IDC_DOWNLOADLIST, TOP_LEFT, CSize(100, theApp.glob_prefs -> GetSplitterbarPosition()));
122	AddAnchor(IDC_UPLOADLIST, CSize(0, theApp.glob_prefs -> GetSplitterbarPosition()), BOTTOM_RIGHT);
123	AddAnchor(IDC_QUEUELIST, CSize(0, theApp.glob_prefs -> GetSplitterbarPosition()), BOTTOM_RIGHT);
124	AddAnchor(IDC_UPLOAD_TEXT, CSize(0, theApp.glob_prefs -> GetSplitterbarPosition()), BOTTOM_RIGHT);
125	AddAnchor(IDC_UPLOAD_ICO, CSize(0, theApp.glob_prefs -> GetSplitterbarPosition()), BOTTOM_RIGHT);
126	AddAnchor(IDC_QUEUECOUNT, BOTTOM_LEFT);
127	AddAnchor(IDC_TSTATIC1, BOTTOM_LEFT);
128	// splitting functionality
129	CRect rc, rcSpl, rcDown;
130	GetWindowRect(rc);
131	ScreenToClient(rc);
132	rcSpl = rc;
133	rcSpl.top = rc.bottom - 100;
134	rcSpl.bottom = rcSpl.top + 5;
135	rcSpl.left = 55;
136	m_wndSplitter.Create(WS_CHILD \| WS_VISIBLE, rcSpl, this, IDC_SPLITTER);
137	SetInitLayout();
138	// create tooltip
139	m_ttip.Create(this);
140	m_ttip.SetDelayTime(TTDT_AUTOPOP, 20000);
141	m_ttip.SetDelayTime(TTDT_INITIAL, theApp.glob_prefs -> GetToolTipDelay() *1000);
142	// recognize \n chars!:
143	m_ttip.SendMessage(TTM_SETMAXTIPWIDTH, 0, SHRT_MAX);
144	m_ttip.AddTool( &downloadlistctrl);
145	m_ttip.AddTool( &uploadlistctrl);
146	m_iOldToolTipItemDown = - 1;
147	m_iOldToolTipItemUp = - 1;
148	m_iOldToolTipItemQueue = - 1;
149	#endif
150	return true;	106	return true;
151	}	107	}
152		108
Lines 159-548 Link Here
159	//this->GetDlgItem(IDC_QUEUECOUNT)->SetWindowText(buffer);	115	//this->GetDlgItem(IDC_QUEUECOUNT)->SetWindowText(buffer);
160	}	116	}
161		117
162	#if 0
163	void CTransferWnd:: DoDataExchange(CDataExchange *pDX)
164	{
165	CResizableDialog:: DoDataExchange(pDX);
166	DDX_Control(pDX, IDC_UPLOADLIST, uploadlistctrl);
167	DDX_Control(pDX, IDC_DOWNLOADLIST, downloadlistctrl);
168	DDX_Control(pDX, IDC_QUEUELIST, queuelistctrl);
169	}
170
171	#endif
172
173	void CTransferWnd:: SetInitLayout()	118	void CTransferWnd:: SetInitLayout()
174	{	119	{
175	#if 0
176	CRect rcDown, rcSpl, rcW;
177	CWnd *pWnd;
178	GetWindowRect(rcW);
179	ScreenToClient(rcW);
180	LONG splitpos = (theApp.glob_prefs -> GetSplitterbarPosition() *rcW.Height()) /100;
181	pWnd = GetDlgItem(IDC_DOWNLOADLIST);
182	pWnd -> GetWindowRect(rcDown);
183	ScreenToClient(rcDown);
184	rcDown.right = rcW.right - 7;
185	rcDown.bottom = splitpos - 5;
186	downloadlistctrl.MoveWindow(rcDown);
187	pWnd = GetDlgItem(IDC_UPLOADLIST);
188	pWnd -> GetWindowRect(rcDown);
189	ScreenToClient(rcDown);
190	rcDown.right = rcW.right - 7;
191	rcDown.bottom = rcW.bottom - 20;
192	rcDown.top = splitpos + 20;
193	uploadlistctrl.MoveWindow(rcDown);
194	pWnd = GetDlgItem(IDC_QUEUELIST);
195	pWnd -> GetWindowRect(rcDown);
196	ScreenToClient(rcDown);
197	rcDown.right = rcW.right - 7;
198	rcDown.bottom = rcW.bottom - 20;
199	rcDown.top = splitpos + 20;
200	queuelistctrl.MoveWindow(rcDown);
201	rcSpl = rcDown;
202	rcSpl.top = rcDown.bottom + 4;
203	rcSpl.bottom = rcSpl.top + 5;
204	rcSpl.left = 95;
205	m_wndSplitter.MoveWindow(rcSpl, true);
206	DoResize(0);
207	#endif
208	}	120	}
209		121
210	void CTransferWnd:: DoResize(int delta)	122	void CTransferWnd:: DoResize(int delta)
211	{	123	{
212	#if 0
213	CSplitterControl:: ChangeHeight( &downloadlistctrl, delta);
214	CSplitterControl:: ChangeHeight( &uploadlistctrl, - delta, CW_BOTTOMALIGN);
215	CSplitterControl:: ChangeHeight( &queuelistctrl, - delta, CW_BOTTOMALIGN);
216	UpdateSplitterRange();
217	Invalidate();
218	UpdateWindow();
219	#endif
220	}	124	}
221		125
222	// setting splitter range limits	126	// setting splitter range limits
223	void CTransferWnd:: UpdateSplitterRange()	127	void CTransferWnd:: UpdateSplitterRange()
224	{	128	{
225	#if 0
226	CRect rcDown, rcUp, rcW, rcSpl;
227	CWnd *pWnd;
228	GetWindowRect(rcW);
229	ScreenToClient(rcW);
230	pWnd = GetDlgItem(IDC_DOWNLOADLIST);
231	pWnd -> GetWindowRect(rcDown);
232	ScreenToClient(rcDown);
233	pWnd = GetDlgItem(IDC_UPLOADLIST);
234	pWnd -> GetWindowRect(rcUp);
235	ScreenToClient(rcUp);
236	pWnd = GetDlgItem(IDC_QUEUELIST);
237	pWnd -> GetWindowRect(rcUp);
238	ScreenToClient(rcUp);
239	theApp.glob_prefs -> SetSplitterbarPosition((rcDown.bottom *100) /rcW.Height());
240	RemoveAnchor(IDC_DOWNLOADLIST);
241	RemoveAnchor(IDC_UPLOADLIST);
242	RemoveAnchor(IDC_QUEUELIST);
243	AddAnchor(IDC_DOWNLOADLIST, TOP_LEFT, CSize(100, theApp.glob_prefs -> GetSplitterbarPosition()));
244	AddAnchor(IDC_UPLOADLIST, CSize(0, theApp.glob_prefs -> GetSplitterbarPosition()), BOTTOM_RIGHT);
245	AddAnchor(IDC_QUEUELIST, CSize(0, theApp.glob_prefs -> GetSplitterbarPosition()), BOTTOM_RIGHT);
246	m_wndSplitter.SetRange(rcDown.top + 50, rcUp.bottom - 40);
247	#endif
248	}	129	}
249		130
250	#if 0
251	LRESULT CTransferWnd:: DefWindowProc(UINT message, WPARAM wParam, LPARAM lParam)
252	{
253	switch (message)
254	{
255	// arrange transferwindow layout
256	case WM_PAINT:
257	if (m_wndSplitter)
258	{
259	CRect rcDown, rcSpl, rcW;
260	CWnd *pWnd;
261	GetWindowRect(rcW);
262	ScreenToClient(rcW);
263	pWnd = GetDlgItem(IDC_DOWNLOADLIST);
264	pWnd -> GetWindowRect(rcDown);
265	ScreenToClient(rcDown);
266	if (rcW.Height() > 0)
267	{
268	// splitter paint update
269	rcSpl = rcDown;
270	rcSpl.top = rcDown.bottom + 8;
271	rcSpl.bottom = rcSpl.top + 5;
272	rcSpl.left = 95;
273	GetDlgItem(IDC_UPLOAD_TEXT) -> MoveWindow(30, rcSpl.top - 5, 90, 16);
274	GetDlgItem(IDC_UPLOAD_ICO) -> MoveWindow(10, rcSpl.top - 5, 16, 16);
275	m_wndSplitter.MoveWindow(rcSpl, true);
276	UpdateSplitterRange();
277	}
278	}
279	break;
280	case WM_NOTIFY:
281	if (wParam == IDC_SPLITTER)
282	{
283	SPC_NMHDR pHdr = (SPC_NMHDR ) lParam;
284	DoResize(pHdr -> delta);
285	}
286	break;
287	case WM_WINDOWPOSCHANGED:
288	{
289	CRect rcW;
290	GetWindowRect(rcW);
291	ScreenToClient(rcW);
292	if (m_wndSplitter &&rcW.Height() > 0) Invalidate();
293	break;
294	}
295	case WM_SIZE:
296	if (m_wndSplitter)
297	{
298	CRect rcDown, rcSpl, rcW;
299	CWnd *pWnd;
300	GetWindowRect(rcW);
301	ScreenToClient(rcW);
302	if (rcW.Height() > 0)
303	{
304	pWnd = GetDlgItem(IDC_DOWNLOADLIST);
305	pWnd -> GetWindowRect(rcDown);
306	ScreenToClient(rcDown);
307	long splitpos = (theApp.glob_prefs -> GetSplitterbarPosition() *rcW.Height()) /100;
308	rcSpl.right = rcDown.right;
309	rcSpl.top = splitpos + 10;
310	rcSpl.bottom = rcSpl.top + 5;
311	rcSpl.left = 95;
312	m_wndSplitter.MoveWindow(rcSpl, true);
313	}
314	}
315	break;
316	}
317	return CDialog:: DefWindowProc(message, wParam, lParam);
318	}
319
320	#endif
321
322	#if 0
323	// CTransferWnd message handlers
324	BOOL CTransferWnd:: PreTranslateMessage(MSG *pMsg)
325	{
326	// handle tooltip updating, when mouse is moved from one item to another
327	if (pMsg -> message == WM_MOUSEMOVE)
328	UpdateToolTips();
329	// relay mouse events to tooltip control
330	if (pMsg -> message == WM_LBUTTONDOWN \|\| pMsg -> message == WM_LBUTTONUP \|\| pMsg -> message == WM_MOUSEMOVE)
331	m_ttip.RelayEvent(pMsg);
332	return CResizableDialog:: PreTranslateMessage(pMsg);
333	}
334
335	#endif
336
337	void CTransferWnd:: UpdateToolTips(void)	131	void CTransferWnd:: UpdateToolTips(void)
338	{	132	{
339	#if 0
340	int sel = GetItemUnderMouse( &downloadlistctrl);
341	if (sel != - 1)
342	{
343	if (sel != m_iOldToolTipItemDown)
344	{
345	if (m_ttip.IsWindowVisible())
346	m_ttip.Update();
347	m_iOldToolTipItemDown = sel;
348	return;
349	}
350	}
351	int sel2 = GetItemUnderMouse( &uploadlistctrl);
352	if (sel2 != - 1)
353	{
354	if (sel2 != m_iOldToolTipItemUp)
355	{
356	if (m_ttip.IsWindowVisible())
357	m_ttip.Update();
358	m_iOldToolTipItemUp = sel2;
359	return;
360	}
361	}
362	/* no tooltips needed ATM
363	int sel3 = GetItemUnderMouse(&queuelistctrl);
364	if (sel3 != -1)
365	{
366	if (sel3 != m_iOldToolTipItemQueue)
367	{
368	if (m_ttip.IsWindowVisible())
369	m_ttip.Update();
370	m_iOldToolTipItemQueue = sel3;
371	}
372	}
373	*/
374	if (sel == - 1 &&sel2 == - 1 /&& sel3 != -1/
375	)
376	m_ttip.Pop();
377	#endif
378	}	133	}
379		134
380	int CTransferWnd:: GetItemUnderMouse(wxListCtrl *ctrl)	135	int CTransferWnd:: GetItemUnderMouse(wxListCtrl *ctrl)
381	{	136	{
382	#if 0
383	CPoint pt;
384	:: GetCursorPos( &pt);
385	ctrl -> ScreenToClient( &pt);
386	LVHITTESTINFO hit, subhit;
387	hit.pt = pt;
388	subhit.pt = pt;
389	ctrl -> SubItemHitTest( &subhit);
390	int sel = ctrl -> HitTest( &hit);
391	if (sel != LB_ERR && (hit.flags &LVHT_ONITEM))
392	{
393	if (subhit.iSubItem == 0)
394	return sel;
395	}
396	return LB_ERR;
397	#endif
398	}	137	}
399		138
400	#if 0
401	BOOL CTransferWnd:: OnToolTipNotify(UINT id, NMHDR pNMH, LRESULT pResult)
402	{
403	TOOLTIPTEXT pText = (TOOLTIPTEXT ) pNMH;
404	int control_id =:: GetDlgCtrlID((HWND) pNMH -> idFrom);
405	if (!control_id)
406	return FALSE;
407	CString info;
408	if (control_id == IDC_DOWNLOADLIST)
409	{
410	if (downloadlistctrl.GetItemCount() < 1)
411	return FALSE;
412	int sel = GetItemUnderMouse( &downloadlistctrl);
413	if (sel < 0 \|\| sel == 65535)
414	return FALSE;
415	// build info text and display it
416	CtrlItem_Struct content = (CtrlItem_Struct ) downloadlistctrl.GetItemData(sel);
417	// for downloading files:
418	if (content -> type == 1)
419	{
420	CPartFile partfile = (CPartFile ) content -> value;
421	CString strHash;
422	strHash.Format("%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X",
423	partfile -> GetFileHash() [0], partfile -> GetFileHash() [1], partfile -> GetFileHash() [2], partfile -> GetFileHash() [3], partfile -> GetFileHash() [4], partfile -> GetFileHash() [5], partfile -> GetFileHash() [6], partfile -> GetFileHash() [7],
424	partfile -> GetFileHash() [8], partfile -> GetFileHash() [9], partfile -> GetFileHash() [10], partfile -> GetFileHash() [11], partfile -> GetFileHash() [12], partfile -> GetFileHash() [13], partfile -> GetFileHash() [14], partfile -> GetFileHash() [15]);
425	CTime t(partfile -> GetFileDate());
426	char lsc[50];
427	char compl[50];
428	char buffer[20];
429	CastItoXBytes(partfile -> GetCompletedSize(), lsc);
430	CastItoXBytes(partfile -> GetFileSize(), buffer);
431	sprintf(compl, "%s/%s", lsc, buffer);
432	if (partfile -> lastseencomplete == NULL) sprintf(lsc, GetResString(IDS_UNKNOWN) .MakeLower());
433	else
434	sprintf(lsc, partfile -> lastseencomplete.Format("%A, %x, %X"));
435	float availability = 0;
436	if (partfile -> GetPartCount() != 0)
437	{
438	availability = partfile -> GetAvailablePartCount() *100 / partfile -> GetPartCount();
439	}
440	info.Format(GetResString(IDS_DL_FILENAME) + ": %s (%d %s)\n"
441	+ GetResString(IDS_DATE) + ": %s - " + GetResString(IDS_FD_HASH) + " %s\n"
442	+ GetResString(IDS_PARTINFOS) +
443	GetResString(IDS_PARTINFOS2) + "\n%s",
444	partfile -> GetFileName(), partfile -> GetFileSize(), GetResString(IDS_BYTES),
445	t.Format("%A, %B %d, %Y"), strHash,
446	partfile -> GetPartMetFileName(), partfile -> GetPartCount(), GetResString(IDS_AVAIL), partfile -> GetAvailablePartCount(), availability,
447	(int) partfile -> GetPercentCompleted(), compl, partfile -> GetTransferingSrcCount(),
448	GetResString(IDS_LASTSEENCOMPL) + " " + CString(lsc));
449	// for sources:
450	}
451	else if(content -> type == 3 \|\| content -> type == 2)
452	{
453	CUpDownClient client = (CUpDownClient ) content -> value;
454	in_addr server;
455	server.S_un.S_addr = client -> GetServerIP();
456	info.Format(GetResString(IDS_NICKNAME) + " %s (" + GetResString(IDS_USERID) + ": %u)\n"
457	+ GetResString(IDS_CLIENT) + " %s:%d\n"
458	+ GetResString(IDS_SERVER) + " %s:%d\n"
459	+ GetResString(IDS_SOURCEINFO),
460	client -> GetUserName(), client -> GetUserID(),
461	client -> GetFullIP(), client -> GetUserPort(),
462	inet_ntoa(server), client -> GetServerPort(),
463	/client->GetAskedCount()/
464	0, client -> GetAvailablePartCount());
465	if (content -> type == 2)
466	{
467	// normal client
468	info += GetResString(IDS_CLIENTSOURCENAME) + CString(client -> GetClientFilename());
469	}
470	else
471	{
472	// client asked twice
473	info += GetResString(IDS_ASKEDFAF);
474	}
475	}
476	}
477	else if(control_id == IDC_UPLOADLIST)
478	{
479	if (uploadlistctrl.GetItemCount() < 1)
480	return FALSE;
481	int sel = GetItemUnderMouse( &uploadlistctrl);
482	if (sel < 0 \|\| sel == 65535)
483	return FALSE;
484	CUpDownClient client = (CUpDownClient ) uploadlistctrl.GetItemData(sel);
485	CKnownFile *file = theApp.sharedfiles -> GetFileByID(client -> reqfileid);
486	// build info text and display it
487	info.Format(GetResString(IDS_USERINFO), client -> GetUserName(), client -> GetUserID());
488	if (file)
489	{
490	info += GetResString(IDS_SF_REQUESTED) + CString(file -> GetFileName()) + "\n";
491	CString stat;
492	stat.Format(GetResString(IDS_FILESTATS_SESSION) + GetResString(IDS_FILESTATS_TOTAL),
493	file -> statistic.GetAccepts(), file -> statistic.GetRequests(), file -> statistic.GetTransfered(),
494	file -> statistic.GetAllTimeAccepts(), file -> statistic.GetAllTimeRequests(), file -> statistic.GetAllTimeTransfered());
495	info += stat;
496	}
497	else
498	{
499	info += GetResString(IDS_REQ_UNKNOWNFILE);
500	}
501	}
502	/* no tooltips needed ATM
503	else if (control_id == IDC_QUEUELIST)
504	{
505	if (queuelistctrl.GetItemCount() < 1)
506	return FALSE;
507	int sel = GetItemUnderMouse(&queuelistctrl);
508	if (sel < 0 \|\| sel == 65535)
509	return FALSE;
510	// build info text and display it
511	CUpDownClient* client = (CUpDownClient*)uploadlistctrl.GetItemData(sel);
512	in_addr server;
513	server.S_un.S_addr = client->GetServerIP();
514	info.Format("Nickname: %s (UserID: %u)\n"
515	"Client %s:%d\n"
516	"Server %s:%d\n"
517	"AskedCount: %d - AvailablePartCount: %d",
518	client->GetUserName(), client->GetUserID(),
519	client->GetFullIP(), client->GetUserPort(),
520	inet_ntoa(server), client->GetServerPort(),
521	client->GetAskedCount(), client->GetAvailablePartCount());
522	}
523	*/
524	// release old used buffer:
525	m_strToolTip.ReleaseBuffer();
526	m_strToolTip = info;
527	pText -> lpszText = m_strToolTip.GetBuffer(1);
528	// we are not using a resource:
529	pText -> hinst = NULL;
530	PostMessage(WM_ACTIVATE);
531	return TRUE;
532	}
533
534	#endif
535
536	void CTransferWnd:: SwitchUploadList(wxCommandEvent &evt)	139	void CTransferWnd:: SwitchUploadList(wxCommandEvent &evt)
537	{	140	{
538	if (windowtransferstate == false)	141	if (windowtransferstate == false)
539	{	142	{
540	#if 0
541	uploadlistctrl.Hide();
542	queuelistctrl.Visable();
543	windowtransferstate = 0;
544	GetDlgItem(IDC_UPLOAD_TEXT) -> SetWindowText(GetResString(IDS_ONQUEUE));
545	#endif
546	windowtransferstate = true;	143	windowtransferstate = true;
547	// hide the upload list	144	// hide the upload list
548	queueSizer -> Remove(uploadlistctrl);	145	queueSizer -> Remove(uploadlistctrl);
Lines 554-565 Link Here
554	}	151	}
555	else	152	else
556	{	153	{
557	#if 0
558	queuelistctrl.Hide();
559	uploadlistctrl.Visable();
560	windowtransferstate = 1;
561	GetDlgItem(IDC_UPLOAD_TEXT) -> SetWindowText(GetResString(IDS_TW_UPLOADS));
562	#endif
563	windowtransferstate = false;	154	windowtransferstate = false;
564	// hide the queuelist	155	// hide the queuelist
565	queueSizer -> Remove(queuelistctrl);	156	queueSizer -> Remove(queuelistctrl);
Lines 573-587 Link Here
573		164
574	void CTransferWnd:: Localize()	165	void CTransferWnd:: Localize()
575	{	166	{
576	#if 0
577	GetDlgItem(IDC_DOWNLOAD_TEXT) -> SetWindowText(GetResString(IDS_TW_DOWNLOADS));
578	GetDlgItem(IDC_UPLOAD_TEXT) -> SetWindowText(GetResString(IDS_TW_UPLOADS));
579	GetDlgItem(IDC_TSTATIC1) -> SetWindowText(GetResString(IDS_TW_QUEUE));
580	downloadlistctrl.CreateMenues();
581	downloadlistctrl.Localize();
582	uploadlistctrl.Localize();
583	queuelistctrl.Localize();
584	#endif
585	}	167	}
586		168
587	void CTransferWnd:: OnSelchangeDltab(wxNotebookEvent &evt)	169	void CTransferWnd:: OnSelchangeDltab(wxNotebookEvent &evt)
Lines 777-787 Link Here
777	theApp.downloadqueue -> SetCatStatus(m_dlTab -> GetSelection(), MP_RESUME);	359	theApp.downloadqueue -> SetCatStatus(m_dlTab -> GetSelection(), MP_RESUME);
778	break;	360	break;
779	}	361	}
780	#if 0
781	case MP_RESUMENEXT:
782	theApp.downloadqueue -> StartNextFile(m_dlTab -> GetSelection());
783	break;
784	#endif
785	case IDC_UPLOAD_ICO:	362	case IDC_UPLOAD_ICO:
786	{	363	{
787	wxCommandEvent nullEvt;	364	wxCommandEvent nullEvt;

Lines 233-239 Link Here

(-)xmule/src/UDPSocket.cpp (-8 / +4 lines)
233	sendbuffer = 0;	233	sendbuffer = 0;
234	cur_server = 0;	234	cur_server = 0;
235	serverconnect = in_serverconnect;	235	serverconnect = in_serverconnect;
		236	#if defined(__DEBUG__)
236	printf("*** UDP socket at %d\n", address.Service());	237	printf("*** UDP socket at %d\n", address.Service());
		238	#endif
237	SetEventHandler( *theApp.xmuledlg, ID_SOKETTI);	239	SetEventHandler( *theApp.xmuledlg, ID_SOKETTI);
238	SetNotify(wxSOCKET_INPUT_FLAG);	240	SetNotify(wxSOCKET_INPUT_FLAG);
239	Notify(TRUE);	241	Notify(TRUE);
Lines 375-381 Link Here
375	update -> SetMaxUsers(cur_maxusers);	377	update -> SetMaxUsers(cur_maxusers);
376	update -> SetSoftFiles(cur_softfiles);	378	update -> SetSoftFiles(cur_softfiles);
377	update -> SetHardFiles(cur_hardfiles);	379	update -> SetHardFiles(cur_hardfiles);
378	//printf("->> reading Stats from server, flags are %i\n",uUDPFlags);
379	update -> SetUDPFlags(uUDPFlags);	380	update -> SetUDPFlags(uUDPFlags);
380	theApp.xmuledlg -> serverwnd -> serverlistctrl -> RefreshServer(update);	381	theApp.xmuledlg -> serverwnd -> serverlistctrl -> RefreshServer(update);
381	}	382	}
Lines 410-416 Link Here
410	break;	411	break;
411	}	412	}
412	default:	413	default:
		414	#if defined(__DEBUG__)
413	printf("UDPSocket::ProcessPacket unknown opcode: %02x\n", opcode);	415	printf("UDPSocket::ProcessPacket unknown opcode: %02x\n", opcode);
		416	#endif
414	theApp.downloadqueue -> AddDownDataOverheadOther(size);	417	theApp.downloadqueue -> AddDownDataOverheadOther(size);
415	return false;	418	return false;
416	}	419	}
Lines 492-499 Link Here
492	if (GAddress_INET_SetHostAddress(addr -> GetAddress(), m_SaveAddr.sin_addr.s_addr) == GSOCK_NOERROR)	495	if (GAddress_INET_SetHostAddress(addr -> GetAddress(), m_SaveAddr.sin_addr.s_addr) == GSOCK_NOERROR)
493	{	496	{
494	SendTo( *addr, sendbuffer, sendblen);	497	SendTo( *addr, sendbuffer, sendblen);
495	//only for debugging:
496	//printf("CUDPSocket::SendBuffer to %s:%d\n",(const char *) addr->IPAddress(),addr->Service());
497	}	498	}
498	}	499	}
499	delete addr;	500	delete addr;
Lines 507-513 Link Here
507		508
508	void CUDPSocket:: SendPacket(Packet packet, CServer host)	509	void CUDPSocket:: SendPacket(Packet packet, CServer host)
509	{	510	{
510	//printf("CUDPSocket:: SendPacket opcode=0x%02x size=%u\n",packet->opcode,packet->size);
511	if (Ok())	511	if (Ok())
512	{	512	{
513	wxIPV4address *addr = new wxIPV4address();	513	wxIPV4address *addr = new wxIPV4address();
Lines 518-527 Link Here
518	{	518	{
519	sendblen = packet -> size + 2;	519	sendblen = packet -> size + 2;
520	sendbuffer = new char[sendblen];	520	sendbuffer = new char[sendblen];
521	#if defined(__DEBUG__)
522	//printf("CUDPSocket::SendPacket to %s:%d 0x%02x,%d\n",
523	//(const char *) addr -> IPAddress(), addr -> Service(), packet -> opcode, packet -> size);
524	#endif
525	memcpy(sendbuffer, packet -> GetUDPHeader(), 2);	521	memcpy(sendbuffer, packet -> GetUDPHeader(), 2);
526	memcpy(sendbuffer + 2, packet -> pBuffer, packet -> size);	522	memcpy(sendbuffer + 2, packet -> pBuffer, packet -> size);
527	if(!newprefs01_opt[4]) {	523	if(!newprefs01_opt[4]) {

Lines 279-286 Link Here

(-)xmule/src/UploadClient.cpp (-25 / +16 lines)
279	CFile file;	279	CFile file;
280	byte *filedata = 0;	280	byte *filedata = 0;
281	char *fullname = 0;	281	char *fullname = 0;
282	try
283	{
284	while (!m_BlockRequests_queue.IsEmpty())	282	while (!m_BlockRequests_queue.IsEmpty())
285	{	283	{
286	Requested_Block_Struct *currentblock = m_BlockRequests_queue.GetHead();	284	Requested_Block_Struct *currentblock = m_BlockRequests_queue.GetHead();
Lines 313-320 Link Here
313	if (!srcfile -> IsPartFile())	311	if (!srcfile -> IsPartFile())
314	{	312	{
315	//CFile::modeRead\|CFile::osSequentialScan\|CFile::shareDenyNone)):	313	//CFile::modeRead\|CFile::osSequentialScan\|CFile::shareDenyNone)):
316	if (!file.Open(fullname, CFile:: read))	314	if (!file.Open(fullname, CFile:: read)) {
317	throw GetResString(IDS_ERR_OPEN);	315	throw GetResString(IDS_ERR_OPEN);
		316	}
318	delete[] fullname;	317	delete[] fullname;
319	fullname = 0;	318	fullname = 0;
320	file.Seek(currentblock -> StartOffset);	319	file.Seek(currentblock -> StartOffset);
Lines 331-367 Link Here
331	CPartFile partfile = (CPartFile ) srcfile;	330	CPartFile partfile = (CPartFile ) srcfile;
332	delete[] fullname;	331	delete[] fullname;
333	fullname = 0;	332	fullname = 0;
334	partfile -> m_hpartfile.Seek(currentblock -> StartOffset);	333	partfile -> Seek(currentblock -> StartOffset);
335	filedata = new byte[togo + 500];	334	filedata = new byte[togo + 500];
336	if (uint32 done = partfile -> m_hpartfile.Read(filedata, togo) != togo)	335	if (uint32 done = partfile -> Read(filedata, togo) != togo)
337	{	336	{
338	partfile -> m_hpartfile.Seek(0);	337	partfile -> Seek(0);
339	partfile -> m_hpartfile.Read(filedata + done, togo - done);	338	(void)partfile -> Read(filedata + done, togo - done);
340	}	339	}
341	}	340	}
342	SetUploadFileID(currentblock -> FileID);	341	SetUploadFileID(currentblock -> FileID);
343	if (m_byDataCompVer == 1 && (!strstr(srcfile -> GetFileName(), ".zip")) && (!strstr(srcfile -> GetFileName(), ".rar")) && (!strstr(srcfile -> GetFileName(), ".ace")))	342	if (m_byDataCompVer == 1 && (!strstr(srcfile -> GetFileName(), ".zip")) && (!strstr(srcfile -> GetFileName(), ".rar")) && (!strstr(srcfile -> GetFileName(), ".ace"))) {
344	CreatePackedPackets(filedata, togo, currentblock);	343	CreatePackedPackets(filedata, togo, currentblock);
345	else	344	} else {
346	CreateStandartPackets(filedata, togo, currentblock);	345	CreateStandartPackets(filedata, togo, currentblock);
		346	}
347	// file statistic	347	// file statistic
348	srcfile -> statistic.AddTransferred(togo);	348	srcfile -> statistic.AddTransferred(togo);
349	m_DoneBlocks_list.AddHead(m_BlockRequests_queue.RemoveHead());	349	m_DoneBlocks_list.AddHead(m_BlockRequests_queue.RemoveHead());
350	delete[] filedata;	350	delete[] filedata;
351	filedata = 0;	351	filedata = 0;
352	}	352	}
353	}
354	catch(wxString error)
355	{
356	theApp.xmuledlg -> AddDebugLogLine(false, GetResString(IDS_ERR_CLIENTERRORED), GetUserName(), error.GetData());
357	theApp.uploadqueue -> RemoveFromUploadQueue(this);
358	if (filedata)
359	delete filedata;
360	if (fullname)
361	delete[] fullname;
362	return false;
363	}
364	// theApp.xmuledlg->AddDebugLogLine(false,"Debug: Packet done. Size: %i",blockpack->GetLength());
365	return true;	353	return true;
366	}	354	}
367		355
Lines 458-471 Link Here
458	CMemFile memfile(output, newsize);	446	CMemFile memfile(output, newsize);
459	togo = newsize;	447	togo = newsize;
460	uint32 nPacketSize;	448	uint32 nPacketSize;
461	if (togo > 10240)	449	if (togo > 10240) {
462	nPacketSize = togo/ (uint32)(togo/10240);	450	nPacketSize = togo/ (uint32)(togo/10240);
463	else	451	} else {
464	nPacketSize = togo;	452	nPacketSize = togo;
		453	}
465	while (togo)	454	while (togo)
466	{	455	{
467	if (togo < nPacketSize *2)	456	if (togo < nPacketSize *2) {
468	nPacketSize = togo;	457	nPacketSize = togo;
		458	}
469	togo -= nPacketSize;	459	togo -= nPacketSize;
470	Packet *packet = new Packet(OP_COMPRESSEDPART, nPacketSize + 24, OP_EMULEPROT);	460	Packet *packet = new Packet(OP_COMPRESSEDPART, nPacketSize + 24, OP_EMULEPROT);
471	memcpy( &packet -> pBuffer[0], GetUploadFileID(), 16);	461	memcpy( &packet -> pBuffer[0], GetUploadFileID(), 16);
Lines 484-491 Link Here
484	if (tempreqfileid)	474	if (tempreqfileid)
485	newreqfile = theApp.sharedfiles -> GetFileByID(tempreqfileid);	475	newreqfile = theApp.sharedfiles -> GetFileByID(tempreqfileid);
486	CKnownFile *oldreqfile = theApp.sharedfiles -> GetFileByID(requpfileid);	476	CKnownFile *oldreqfile = theApp.sharedfiles -> GetFileByID(requpfileid);
487	if (newreqfile == oldreqfile)	477	if (newreqfile == oldreqfile) {
488	return;	478	return;
		479	}
489	if (newreqfile)	480	if (newreqfile)
490	{	481	{
491	newreqfile -> AddQueuedCount();	482	newreqfile -> AddQueuedCount();

Lines 1-12 Link Here

(-)xmule/src/resource/newprefs01.pm (-4 / +5 lines)
1	0,New Preferences	1	0,New Preferences
2	-1,separator	2	-1,separator
3	20101,Secure Identification on/off	3	20101,Secure Identification active
4	20106,Automatic-Random-Privatekey-Generator	4	20106,Automatic-Random-Privatekey-Generator
		5	20107,Renew userhash on start:
5	-1,separator	6	-1,separator
6	20102,Source-Exchange on/off	7	20102,Source-Exchange active
7	-1,separator	8	-1,separator
8	20103,xMule-Identification as eMule on/off	9	20103,xMule-Identification as eMule
9	-1,separator	10	-1,separator
10	20104,Disconnect xMule from ed2k-Network	11	20104,Disconnect xMule from ed2k-Network
11	-1,separator	12	-1,separator
12	20105,Compressed Partfile-Support	13	20105,Dynamic Partfile-Support