/**********************************************/
/*                                            */    
/* scolinstaller.cpp                          */
/*                                            */
/* main installer functions                   */
/* (functions from old main.cpp)              */
/*                                            */
/* scol v 4                                   */
/*                                            */
/**********************************************/


// Modifications History
//
//$ LB (28/08/2001) : update Netscape management calls
//                    add EnumNetscape6Paths script function
//
//$LB (25/03/2005) : don't check the date anymore, force the new plugin to be registered	
//


#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <io.h>
#include <commctrl.h>
#include <process.h>               
#include <direct.h>
#include <errno.h>
#define CONST_VTABLE
#include <ole2.h>
#include <shlguid.h>
#include <shlobj.h>
#include <sys\stat.h>

#include "resrc1.h"
#include "dirtree.h"
#include "defines.h"
#include "iprocess.h"
#include "inetscape.h"
#include "iwinversion.h"
#include "iFilesOperations.h"
#include "iReboot.h"
#include "iBackground.h"
#include "iperms.h"

#include "sql.h"
#include "sqlext.h"
#include "odbcinst.h"






HWND MainHWND;
DWORD MainHWNDwidth;
DWORD MainHWNDheight;
DWORD MainHWNDtop;
DWORD MainHWNDleft;
HINSTANCE Instance;




LangType langtype[NLangID]= 
{
  {LANG_NEUTRAL, "Neutral"},
  {LANG_ARABIC, "Arabic"},
  {LANG_BULGARIAN, "Bulgarian"},
  {LANG_CATALAN, "Catalan "},
  {LANG_CHINESE, "ChineseS"},
  {(SUBLANG_CHINESE_TRADITIONAL<<10)+LANG_CHINESE,"ChineseT"},
  {LANG_CZECH, "Czech"},
  {LANG_DANISH, "Danish"},
  {LANG_GERMAN, "German"},
  {LANG_GREEK, "Greek"},
  {LANG_ENGLISH, "English"},
  {LANG_SPANISH, "Spanish"},
  {LANG_FINNISH, "Finnish"},
  {LANG_FRENCH, "French"},
  {LANG_HEBREW, "Hebrew"},
  {LANG_HUNGARIAN, "Hungarian"},
  {LANG_ICELANDIC, "Icelandic"},
  {LANG_ITALIAN, "Italian"},
  {LANG_JAPANESE, "Japanese"},
  {LANG_KOREAN, "Korean"},
  {LANG_DUTCH, "Dutch"},
  {LANG_NORWEGIAN, "Norwegian"},
  {LANG_POLISH, "Polish"},
  {LANG_PORTUGUESE, "Portuguese"},
  {LANG_ROMANIAN, "Romanian"},
  {LANG_RUSSIAN, "Russian"},
  {LANG_CROATIAN, "Croatian"},
  {LANG_SERBIAN, "Serbian"},
  {LANG_SLOVAK, "Slovak"},
  {LANG_ALBANIAN, "Albanian"},
  {LANG_SWEDISH, "Swedish"},
  {LANG_THAI, "Thai"},
  {LANG_TURKISH, "Turkish"},
  {LANG_URDU, "Urdu"},
  {LANG_INDONESIAN, "Indonesian"},
  {LANG_UKRAINIAN, "Ukrainian"},
  {LANG_BELARUSIAN, "Belarusian"},
  {LANG_SLOVENIAN, "Slovenian"},
  {LANG_ESTONIAN, "Estonian"},
  {LANG_LATVIAN, "Latvian"},
  {LANG_LITHUANIAN, "Lithuanian"},
  {LANG_FARSI, "Farsi"},
  {LANG_VIETNAMESE, "Vietnamese"},
  {LANG_ARMENIAN, "Armenian"},
  {LANG_AZERI, "Azeri"},
  {LANG_BASQUE, "Basque"},
  {LANG_MACEDONIAN, "Macedonian"},
  {LANG_AFRIKAANS, "Afrikaans"},
  {LANG_GEORGIAN, "Georgian"},
  {LANG_FAEROESE, "Faeroese"},
  {LANG_HINDI, "Hindi"},
  {LANG_MALAY, "Malay"},
  {LANG_KAZAK, "Kazak"},
  {LANG_SWAHILI, "Swahili"},
  {LANG_UZBEK, "Uzbek"},
  {LANG_TATAR, "Tatar"},
  {LANG_BENGALI, "Bengali"},
  {LANG_PUNJABI, "Punjabi"},
  {LANG_GUJARATI, "Gujarati"},
  {LANG_ORIYA, "Oriya"},
  {LANG_TAMIL, "Tamil"},
  {LANG_TELUGU, "Telugu"},
  {LANG_KANNADA, "Kannada"},
  {LANG_MALAYALAM, "Malayalam"},
  {LANG_ASSAMESE, "Assamese"},
  {LANG_MARATHI, "Marathi"},
  {LANG_SANSKRIT, "Sanskrit"},
  {LANG_KONKANI, "Konkani"},
  {LANG_MANIPURI, "Manipuri"},
  {LANG_SINDHI, "Sindhi"},
  {LANG_KASHMIRI, "Kashmiri"},
  {LANG_NEPALI, "Nepali"}
};

LANGID langid;


BOOL Mini=FALSE;
BOOL Silent=FALSE;
BOOL Force=FALSE;
BOOL Debug=FALSE;

int LastResult;

Operation Operations[N_OP]=
{
  {ICREATEDIR     ,"MkDir",1},                       
  {ICOPYA         ,"CopyA",2},                       
  {ICOPY          ,"Copy",1},                        
  {ICOPYS         ,"CopyS",2},                       
  {ICOPYD         ,"CopyD",2},                       
  {IMOVEA         ,"MoveA",2},                       
  {IMOVE          ,"Move",1},                        
  {IMOVES         ,"MoveS",2},                       
  {IMOVED         ,"MoveD",2},                       
  //scol v 4 : doesn't need this anymore
  //{IREGISTER      ,"Register",1},
  {IEnumNetscape6Paths  ,"EnumNetscape6Paths",1}, 
  {ICREATEGROUP   ,"MkPgmGroup",1},                  
  {ICREATELINK    ,"MkLink",2},                      
  {ICOPYDIRTODEST ,"CopyDir2Dest",2},                
  {ISERIAL        ,"SetSerialNumber",0},             
  {ICREATESRCLINK ,"CreateSourceLink",2},            
  {IADDPACK       ,"AddPartition",1},                
  {ISet           ,"set",2},                         
  {IGet           ,"get",2},                         
  {IGoto          ,"goto",1},                        
  {IQuit          ,"quit",2},
  {IGetSerial     ,"GetSerial",0},                   
  {IShowFile      ,"ShowFile",1},                    
  {IGetSystemVars ,"GetSystemVars",0},               
  {IShowInstallDlg,"IShowInstallDlg",0},             
  {IIf            ,"If",0},                          
  {IElse          ,"Else",0},                        
  {IEndif         ,"Endif",0},                       
  {IExist         ,"Exist",1},
  // scol 4 : 
  // ApplyOnFiles (a,b) --> EnumNetscapePaths (c)
  {IEnumNetscapePaths  ,"EnumNetscapePaths",1},                
  {IReturn        ,"Return",0},                      
  {IMsgBoxOK      ,"MsgBoxOK",2},                    
  {IMsgBoxOKCancel,"MsgBoxOKCancel",2},              
  {IDetectTCPIP   ,"DetectTCPIP",0},                 
  {IStrcat        ,"Strcat",2},                      
  {IStrcmp        ,"Strcmp",2},                      
  {IRun           ,"Run",2},                         
  {IDelete        ,"Delete",1},                      
  {IUnregister    ,"Unregister",1},                  
  {IDeltree       ,"Deltree",1},                     
  {IGetPgmGroup   ,"GetPgmGroup",1},                 
  {IDelPgmGroup   ,"DelPgmGroup",1},                 
  {ISetUninstall  ,"SetUninstall",2},                
  {IRegisterFont  ,"RegisterFont",1},                
  {IUnregisterFont,"UnregisterFont",1},              
  {IFindInFile    ,"FindInFile",2},                  
  {IParseFile     ,"ParseFile",2},                   
  {IDetectSCOL    ,"DetectSCOL",0},                  
  {IAppendFile    ,"AppendFile",2},                  
  {IGetTempFileName,"GetTempFileName",0},
  {IInclude       ,"Include",1},                     
  {IDelUninstall  ,"DelUninstall",0},                
  {ISetupType     ,"SetupType",0},
  {IClr           ,"Clr",1},
  {IStricmp       ,"Stricmp",2},
  {IMsgBoxYESNO   ,"MsgBoxYESNO",2},
  {IRunWait       ,"RunWait",2},
  {IDelScmAsso    ,"CleanRegistry",0},
  {IShowWin       ,"ShowWindow",0},
  {IHideWin       ,"HideWindow",0},
  {ICD            ,"CD",1},
  {IGetScolSettings,"GetScolSettings",0},
  {IGetSMTPServer ,"GetSMTPServer",0},
  {IIsScolUpdated ,"IsScolUpdated",1},
  {IIsScolRunning ,"IsScolRunning",0},
  {IImportOldScol ,"ImportOldScol",2},
  {IDeleteAllFiles,"DeleteAllFiles",1},
  {ICheckForDLL   ,"CheckForDLL",1},
  {IIsMini        ,"IsMini",0},
  {ISetText       ,"SetText",1},
  {IQuitErr       ,"quiterr",2},
  {IIsSilent      ,"IsSilent",0},
  {IInstallSuccess,"InstallSuccess",0},
  {ICreateDesktopLink, "CreateDesktopLink",2},
  {IDestroyDesktopLink, "DestroyDesktopLink",1},
  {IIsEnoughSpace,      "IsSpace"},
  {ICreateStartLink,    "CreateStartLink",2},
  {IDestroyStartLink,   "DestroyStartLink",1},
  {IGetVersion,         "GetVersion",2},
  {IIsGreater,          "IsGreater",2},
  {IIsLower,            "IsLower",2},
  {IMkStr,              "MkStr",1},
  {ICopyWord,           "CopyWord",1},
  {IKillScol,           "KillScol", 0},
  {IIsRebootNeeded,     "IsRebootNeeded", 0},
  {IReboot        ,     "Reboot", 2},
  {ICOPYSAFE      ,     "CopySafe", 1},
  {IMOVESAFE      ,     "MoveSafe", 1},
  {ICOPYDIRTODESTSAFE , "CopyDir2DestSafe",2},
  {IBKGApplyBackground, "BkgApplyBackground", 0},
  {IBKGApplyText,       "BkgApplyText", 0},
  {IBKGApplyLogo,       "BkgApplyLogo", 0},
  {IIsUserAuthorized,   "IsUserAuthorized", 0},
  {ICreateDSN,			"CreateDSN", 2},
  {IGetForcedIP,		"GetForcedIP",0},
  {ISetForcedIP,		"SetForcedIP",0},
  {ISetDNSname,			"SetDNSname",1},
  {IReplaceFile,		"ReplaceFile",2},
  {IIsForced,			"IsForced",0},
  {IIntcmp,				"Intcmp",2},
  {IIfPos,				"IfPos",0}
};

Variable vars[NVARS];


FILE* INIFile;


BOOL StopINI=FALSE;
BOOL StopALL=FALSE;
BOOL Uninstall=FALSE;
char Installdir[MAX_PATH];

char License [1024];
char ForcedIP [1024];
char DNSname [1024];

//$ LB, mars 2001
//scol 4
//add infos to print correctly the progress bar
int iProgressBarPos = 0;
int oldinstallfailled = 0;





/****************************************************************/
/*                                                              */
/*     B O D Y                                                  */
/*                                                              */
/****************************************************************/

void _log (char*format,...)
{
  FILE* f;
  va_list arglist;

  if (Debug) {
    f=fopen("c:\\ScolInstaller.log","a+");
    if (!f) return;
    if (!format) return;
    va_start(arglist,format);
    vfprintf(f,format,arglist);
    va_end(arglist);
    fclose(f);
  }
}



BOOL    CALLBACK DlgProc (HWND,UINT,WPARAM,LPARAM);
BOOL    CALLBACK LicenceDlgProc (HWND,UINT,WPARAM,LPARAM);
BOOL    CALLBACK WaiterDlgProc (HWND,UINT,WPARAM,LPARAM);
BOOL    CALLBACK FinishDlgProc (HWND,UINT,WPARAM,LPARAM);
BOOL    CALLBACK SerialNumberDlgProc (HWND,UINT,WPARAM,LPARAM);
BOOL    CALLBACK SetupTypeDlgProc (HWND hDlg,UINT iMsg,WPARAM wParam,LPARAM lParam);
BOOL    CALLBACK ScolSettingsDlgProc (HWND hDlg,UINT iMsg,WPARAM wParam,LPARAM lParam);
BOOL    CALLBACK SMTPDlgProc (HWND hDlg,UINT iMsg,WPARAM wParam,LPARAM lParam);
BOOL    CALLBACK ForcedIPDlgProc (HWND,UINT,WPARAM,LPARAM);

int ProcessIniFile (HWND hDlg,char* section);
int IsEnoughSpace(char*DirectoryName,int space);
int strCutting(char *comm, char **argv);
int strCuttingLine(char *comm, char **argv);

BOOL TOPShowWindow(HWND hWnd, int nCmdShow);











/*********************************************************************/
/*                                                                   */
/*     BODY                                                          */
/*                                                                   */
/*********************************************************************/


/* Affiche une fenêtre en top */
BOOL TOPShowWindow(HWND hWnd, int nCmdShow)
{
	ShowWindow (hWnd, nCmdShow);
	BringWindowToTop (hWnd);
	SetActiveWindow (hWnd);
	return SetForegroundWindow (hWnd);
}



/*
 * Copie d'un mot au format strbuild
 */
char *MBcopyword(char *cr,int *deb)
{
  int i,l,k;
  char *p;

  l=*deb;
  p=(char*)&deb[1];

  for(i=0;i<l;i++)
    {
      k=p[i]&255;
      if ((k=='\\')||(k==' '))
        {
          *(cr++)='\\';
          *(cr++)=k;
        }
      else if (k==10)
        {
          *(cr++)='\\';
          *(cr++)='n';
        }
      else if (k==0)
        {
          *(cr++)='\\';
          *(cr++)='z';
        }
      else if ((k<32)||(k>=128))
        {
          *(cr++)='\\';
          *(cr++)='0'+k/100;
          k=k%100;
          *(cr++)='0'+k/10;
          k=k%10;
          *(cr++)='0'+k;
        }
      else *(cr++)=p[i];
    }
  return cr;
}

int exist (char* fn)
{
  FILE * f;
  int res;
  f=fopen(fn,"rb");
  if (f)
  {
    fseek(f,0,SEEK_END);
    res=ftell(f);
    fclose(f);
    return res;
  } 
  return -1;
}

void initvars()
{
  for (int i=0;i<NVARS;i++) vars[i].name=vars[i].value=NULL;
}

int getvarn (char* name)
{
  int i;
  for (i=0;i<NVARS;i++)
  {
    if (vars[i].name)
    {
      if (!stricmp (vars[i].name,name))
        return i;
    }
  }
  return -1;
}

int setvar(char*name,char*val)
{
  int i;

  i=getvarn(name);
  if (i==-1)
  {
    i=0;
    while ((i<NVARS) && (vars[i].name)) i++;
  }

  if (i<NVARS)
  {
    if (vars[i].name) vars[i].name=(char*)realloc(vars[i].name,strlen (name)+1);
    else vars[i].name=(char*)malloc(strlen (name)+1);
    if (!vars[i].name) return -1;
    
    if (vars[i].value) vars[i].value=(char*)realloc(vars[i].value,strlen(val)+1);
    else vars[i].value=(char*)malloc(strlen(val)+1);
    if (!vars[i].value) 
    {
      free (vars[i].name);
      vars[i].name=NULL;
      return -1;
    }
    strcpy(vars[i].name,name);
    strcpy(vars[i].value,val);
    return i;
  }
  else
    return -1;
}

char* getvar (char* name)
{
  int i=0;
  i=getvarn(name);
  if (i==-1) return NULL;
  return vars[i].value;
}

void clrvar (char* name)
{
  int i=0;
  i=getvarn(name);

  if (i==-1) return;

  if (vars[i].value) 
  {
    free(vars[i].value);
    vars[i].value=NULL;
  }
  if (vars[i].name) 
  {
    free(vars[i].name);
    vars[i].name=NULL;
  }
}

/* modif P.Favre 20/08/99
 * if format includes the 2 chars "\n", replace them by CR-LF
 */
void justify(char *format)
{
  char *ptr;

  for (ptr=format ; *ptr!='\0' ; ptr++)
    if (*ptr=='\\' && *(ptr+1)=='n') {
      *ptr='\r';
      *(ptr+1)='\n';
    }
}

int MsgBox(HWND hw,UINT flag,char *title,char *format, ...)
{
  va_list arglist;
  char buf[4096];
  char just[4096];

  if (!format) format="*** invalid message ***";
  va_start(arglist,format);
  strcpy(just,format);
  justify(just);
  vsprintf(buf,just,arglist);
  va_end(arglist);

  return MessageBox(MainHWND,buf,title,flag|MB_TOPMOST);
}

int SetSemaphore()
{
  HKEY hkey;
  char value[1024];
  long size=1024;
  int res=0;
  unsigned char *v;

  if (RegCreateKeyEx(HKEY_LOCAL_MACHINE,"Software\\Cryo-Networks",0,"",REG_OPTION_NON_VOLATILE,KEY_ALL_ACCESS,NULL,&hkey,NULL)==ERROR_SUCCESS)
  {
    if (RegQueryValue(hkey,"InstallFailled",value,&size)==ERROR_SUCCESS) res=1;
    v=(unsigned char*)"1";
    RegSetValueEx(hkey,"InstallFailled",0,REG_SZ,v,1);
    v=(unsigned char*)"0";
    RegSetValueEx(hkey,"Success",0,REG_SZ,v,1);
    RegCloseKey(hkey);
    RegFlushKey(hkey);
  }
  else res=-1;
  return res;
}

void DelSemaphore()
{
  HKEY hkey;
  if (RegCreateKeyEx(HKEY_LOCAL_MACHINE,"Software\\Cryo-Networks",0,"",REG_OPTION_NON_VOLATILE,KEY_ALL_ACCESS,NULL,&hkey,NULL)==ERROR_SUCCESS)
  {
    RegDeleteValue(hkey,"InstallFailled");
    RegCloseKey(hkey);
    RegFlushKey(hkey);
  }
}

int InstallSuccess()
{
  HKEY hkey;
  int res=0;

  if (RegCreateKeyEx(HKEY_LOCAL_MACHINE,"Software\\Cryo-Networks",0,"",REG_OPTION_NON_VOLATILE,KEY_ALL_ACCESS,NULL,&hkey,NULL)==ERROR_SUCCESS)
  {
    RegDeleteValue(hkey,"InstallFailled");
    RegSetValueEx(hkey,"Success",0,REG_SZ,(unsigned char*)"1",1);
    RegSetValueEx(hkey,"IE",0,REG_SZ,(unsigned char*)getvar("APP_VERSION"),strlen(getvar("VERSION")));
    RegSetValueEx(hkey,"Netscape",0,REG_SZ,(unsigned char*)getvar("APP_VERSION"),strlen(getvar("VERSION")));
    RegCloseKey(hkey);
    RegFlushKey(hkey);
  }
  else res=-1;
  return res;
}

void Error(char *format, ...)
{
  va_list arglist;
  char buf[4096];

	if (!Silent) {
		if (!format) return;
		va_start(arglist,format);
		justify(format);
		vsprintf(buf,format,arglist);
		va_end(arglist);

		MessageBox(MainHWND,buf,getvar("ERROR_TTL"),NULL);
	}
	else return;
}

int GetProgramFilesDir (char* buf)
{
  char MyPath[1024],*path;
  long msize=1024;
  HKEY k;
  RegOpenKey(HKEY_LOCAL_MACHINE,"SOFTWARE\\Microsoft\\Windows\\CurrentVersion", &k);
  if (RegQueryValueEx(k,"ProgramFilesDir",NULL,NULL,(unsigned char*)MyPath,(unsigned long*)&msize)!=ERROR_SUCCESS)
  {
    if (RegQueryValueEx(k,"ProgramFilesPath",NULL,NULL,(unsigned char*)MyPath,(unsigned long*)&msize)!=ERROR_SUCCESS)
      return 0;
  }
  path=MyPath;
  strcat(path,"\\");
  strcpy(buf,path);
  return 1;
}

char* GetLangName(int _langid)
{
  for (int i=0;i<NLangID;i++)
    if (langtype[i].langid==_langid) return langtype[i].langname;

  return "English";
}

void SetLanguageExtensionFile ()
{
  char buf[MAX_PATH];
  FILE*f;

  langid=GetUserDefaultLangID()&0xFF;
  _log("langid=%x\n",langid);

  if (langid==LANG_CHINESE)
  {
	if (GetUserDefaultLangID()>>10==SUBLANG_CHINESE_TRADITIONAL) {
      langid=(SUBLANG_CHINESE_TRADITIONAL<<10)+LANG_CHINESE;
	}
    else if (GetUserDefaultLangID()>>10!=SUBLANG_CHINESE_SIMPLIFIED) {
      langid=LANG_ENGLISH;
	}
  }

  sprintf(buf,"setup.%s.txt",GetLangName(langid));
  _log("recherche %s\n", buf);

  f=fopen(buf,"rt");
  if (f)
  {
	_log("trouvé !\n");
    fclose(f);
    setvar("languagefile",buf);
  }
  else {
    _log("non trouvé => setup.English.txt\n");
    setvar("languagefile","setup.English.txt");
  }
}



/******************************************/
/*                                        */
/* scol 4 :                               */
/*                                        */
/* FindNetscape now in inetscape.cpp      */
/*                                        */ 
/******************************************/


/******************************************/
/*                                        */
/* scol 4 :                               */
/*                                        */
/* IsNetscapeDefault now in inetscape.cpp */
/*                                        */ 
/******************************************/



void GetSystemVars()
{
  char _WINDIR[MAX_PATH];
  char _SYSDIR[MAX_PATH];
  char _SRCDIR[MAX_PATH];
  char _DSTDIR[MAX_PATH];
  char buf[MAX_PATH];

  buf[0]=0;
  GetSystemDirectory(_SYSDIR,MAX_PATH);
  GetWindowsDirectory(_WINDIR,MAX_PATH);
  GetCurrentDirectory(MAX_PATH,_SRCDIR);
  if (_SRCDIR[strlen(_SRCDIR)-1]=='\\') 
    _SRCDIR[strlen(_SRCDIR)-1]=0;

  GetProgramFilesDir (buf);
  setvar("SYSDIR",_SYSDIR);
  setvar("WINDIR",_WINDIR);
  setvar("SRCDIR",_SRCDIR);
  setvar("PROGRAMFILES",buf);
  /* DSTDIR peut être positionné en argument du programme */
  if (Installdir[0]==0) {
	  if (buf[0]==0) {
		  setvar("DSTDIR","c:\\scol");
	  }
	  else {
		  strcpy(_DSTDIR,buf);
		  strcat(_DSTDIR,"scol");
		  setvar("DSTDIR",_DSTDIR);
	  }
  }
  else {
	  setvar("DSTDIR",Installdir);
  }
  GetTempPath(MAX_PATH,buf);
  setvar("WINDOWSTEMP",buf);

  //scol 4
  netscapeInitData();
  //$ LB (28/08/2001) : update Netscape management calls (add 2 last parameters)
  FindNetscape("Netscape 6", "\\", "netscp6.exe", &netscape6PathsTab, &netscape6PathsTabLength);
  FindNetscape("Netscape Navigator", "\\program\\", "netscape.exe", &netscapePathsTab, &netscapePathsTabLength);
  IsNetscapeDefault();

  SetLanguageExtensionFile();

  switch (iGetWinVersion()) {
  case I_WINVER_NT4:
  case I_WINVER_2000:
  case I_WINVER_WHISTLER:
	  setvar("WINVERSION","NT");
	  break;
  case I_WINVER_95:
  case I_WINVER_98:
  case I_WINVER_ME:
	  setvar("WINVERSION","WINDOWS");
	  break;
  default:
	  setvar("WINVERSION","NULL");
	  break;
  }

//  MsgBox(MainHWND,NULL,"Dirs","SYSTEM: %s\nWINDOWS:%s\nSRC:%s\nDST:%s\n",SYSDIR,WINDIR,SRCDIR,DSTDIR);
}




/***************************************/
/*                                     */
/* scol 4 :                            */
/*                                     */
/* IsScolRunning now in iprocess.cpp   */
/*                                     */ 
/***************************************/




int DetectTCPIP ()
{
  WORD wVersionRequested;
  WSADATA wsaData;
  int err; 
  SOCKET s;

  wVersionRequested = MAKEWORD( 1, 1 ); 
  err = WSAStartup( wVersionRequested, &wsaData );
  if ( err != 0 ) 
  {
    return 0;
  } 
  if ( LOBYTE( wsaData.wVersion ) != 1 || HIBYTE( wsaData.wVersion ) != 1 ) 
  {
    WSACleanup( );
    return 0; 
  }
  
  PROTOENT * proto;
  proto=getprotobyname ("TCP");
  if (!proto)
  {
    WSACleanup( );
    return 0;
  }
  if (!getprotobyname ("IP"))
  {
    WSACleanup( );
    return 0;
  }
  if (!getprotobyname ("UDP"))
  {
    WSACleanup( );
    return 0;
  }

  if ((s=socket(AF_INET,SOCK_STREAM,6))==SOCKET_ERROR)  
    return 0;

/*
    switch (WSAGetLastError())
  {
    case WSAEFAULT:
      Error("The name parameter is not a valid part of the user address space, or the buffer size specified by namelen parameter is too small to hold the complete host name. ");
      break;
    case WSANOTINITIALISED:
      Error("A successful WSAStartup must occur before using this function");
      break;
    case WSAENETDOWN:
      Error("The network subsystem has failed.");
      break;
    case WSAEINPROGRESS:
      Error("A blocking Windows Sockets 1.1 call is in progress, or the service provider is still processing a callback function");
      break;
    case WSAEAFNOSUPPORT:
      Error("The specified address family is not supported.");
    case WSAEPROTONOSUPPORT:
      Error("The specified protocol is not supported.");
    case WSAEPROTOTYPE:
      Error("The specified protocol is the wrong type for this socket.");
    case WSAESOCKTNOSUPPORT:
      Error("The specified socket type is not supported in this address family.");
 
   }*/

  return 1;
}

int CheckForDLL(char*n)
{
  HINSTANCE i;
  i=LoadLibrary(n);
  if (!i) return 0;
  FreeLibrary(i);
  return 1;
}

bool getusmpackline(FILE*f,char*res)
{
  char buf[1024];
  char*p=buf;
  char*pp;
  bool flag=false;
//  MessageBox(NULL,"getusmpackline...","getusmpackline",0);
  while (fgets(buf,1024,f))
  {
//    MessageBox(NULL,buf,"getusmpackline:",0);
    p=buf;
    while (*p<33 && *p) p++;
    if (*p && *p!='#' && strlen(p)>3)
    {
//      strcpy(res,p);
      pp=res;
      flag=false;
      while(*p) { 
        if (flag)
        {
          if (*p=='\\') *pp='/';
          else if (*p==' ') 
          {
            *pp++='\\';
            *pp=' ';
          }
          else if (*p=='"') 
          {
            pp--;
            flag=false;
          }
          else *pp=*p;
          p++;
          pp++;
        }
        else
        {
          if (*p=='\\') *pp='/';
          else if (*p=='"') 
          {
            pp--;
            flag=true;
          }
          else *pp=*p;
          p++;
          pp++;
        }
      }
      *pp=0;
//      MessageBox(NULL,res,"getusmpackline result:",0);
      return true;
    }
  }
  return false;
}

bool FindDll(FILE*f,const char*n,char*buf)
{
  char b[1024];
  char*p=b;
  while (fgets(b,1024,f))
  {
    p=b;
    while (*p<33 && *p) p++;
    if (!strnicmp(n,p,strlen(n)))
    {
//      MessageBox(NULL,b,"DLL",0);
      strcpy(buf,p);
      return true;
    }
  }
  return false;
}

bool ImportUsmpack()
{
  bool cont=true;
  FILE*f,*usmini;
  char buf[1024];
  sprintf(buf,"%s\\usmpack.ini",DSTDIR);
  f=fopen(buf,"r");
  if (!f) 
  {
    return true;
  }
  
  sprintf(buf,"%s\\usm.ini",DSTDIR);
  usmini=fopen(buf,"a+");
  if (!usmini)
  {
    fclose(f);
    return false;
  }

  strcpy(buf,"disk ./Cache 64000");
  getusmpackline(f,buf+5);
  fprintf(usmini,"%s",buf);
    
  strcpy(buf,"disk ./Partition 0");
  getusmpackline(f,buf+5);
  fprintf(usmini,"%s",buf);

  while (getusmpackline(f,buf+5)) fprintf(usmini,"%s",buf);

  fclose(f);

  sprintf(buf,"%s\\usmdll.ini",DSTDIR);
  f=fopen(buf,"r");
  if (f) 
  {
    if (FindDll(f,"dwarpdll.dll",buf))
    {
      fprintf(usmini,"plugin %s",buf);
    }
    fclose(f);
  }

  fclose(usmini);
  return true;
}





//scol 4
//add SetProgressBarPos to make the progress bar active
DWORD SetProgressBarPos (HWND hwnddialog, LPCTSTR src)
{
  iProgressBarPos += 1;
  SendMessage(GetDlgItem(hwnddialog,IDC_FILEPROGRESS),PBM_SETPOS,(DWORD)((iProgressBarPos * 100)/APP_SIZE),0);
  return 0;
}





/***************************************************/
/*                                                 */
/* scol 4 :                                        */
/*                                                 */
/* iCopyF is now interface to ifopCopyF            */
/* --> ifopCopyF now in iFilesOperations.cpp       */
/*                                                 */ 
/***************************************************/
DWORD iCopyF (HWND hwnddialog, LPCTSTR source, LPCTSTR dest, DWORD mode)
{

	if (source && dest)
	{
		if (!ifopCopyF(source, dest, mode))
		{
			if (!Silent)
				MsgBox (MainHWND, MB_OK, getvar("ERROR_COPY_TTL"), getvar("ERROR_COPY_MSG"), source, dest);
			StopINI=TRUE;
			StopALL=TRUE;
			oldinstallfailled=1;
			return 0;
		}
		else
		{
			//scol 4 : progress bar
			SetProgressBarPos (hwnddialog, source);
			return 1;
		}
	}
	return 1;
}















bool GetPluginList(char plugs[256*256])
{
  FILE*usmini;
  int i=0;
  char b[1024];
  char*p=b;
  
  sprintf(b,"%s\\usm.ini",SRCDIR);
  usmini=fopen(b,"r");
  if (!usmini)
  {
    oldinstallfailled=1;
    return false;
  }

  while (fgets(b,1024,usmini))
  {
    p=b;
    while (*p<33 && *p) p++;
    if (!strnicmp("plugin",p,strlen("plugin")))
    {
      p+=6;
      while (*p<33 && *p) p++;
      strcpy(plugs+(256*i++),p);
    }
  }

  fclose(usmini);
  return true;
}




char* MostRecentPlug(char *p,char plug[256*256])
{
  char name[256],date[256],*p1,*p2;
  int n;
  static char result[256];

  p1=p;
  while(*p1 && *p1!='-' && *p1!='.') p1++;
  strncpy(name,p,p1-p);
  name[p1-p]=0;
  if (!*p1 || *p1=='.') strcpy(date,"");
  else 
  {
    p2=p1; 
    while (*p2 && *p2!='.') p2++;
    strncpy(date,p1,p2-p1);
    date[p2-p1]=0;
  }
  for (n=0;n<256;n++)
  {
//    if (!plug[n*256]) return p;
    if (!strnicmp(name,&plug[n*256],strlen(name)))
    {
 
	  //$LB (25/03/2005) : don't check the date anymore, force the new plugin to be registered	
        strcpy(result,plug+n*256);
        plug[n*256]=0;
        return result;

		/*
	  if (strnicmp(date,&plug[n*256+strlen(name)],strlen(date))>0) 
      {



        plug[n*256]=0;
        return p;
      }
      else
      {
        strcpy(result,plug+n*256);
        plug[n*256]=0;
        return result;
      }
	  */
    }
  }
  return p;
}

bool ImportPlugs()
{
  char plugs[256*256];
  FILE*usmini;
  FILE*newini;
  int i=0;
  char n1[1024];
  char n2[1024];
  char b[1024];
  char*p=b;

  memset(plugs,0,256*256);

  GetPluginList(plugs);

  sprintf(n1,"%s\\usm.ini",DSTDIR);
  usmini=fopen(n1,"r");
  sprintf(n2,"%s\\newusm.ini",DSTDIR);
  newini=fopen(n2,"w");
  if (!usmini)
  {
    oldinstallfailled=1;
    return false;
  }

  while (fgets(b,1024,usmini))
  {
    p=b;
    while (*p<33 && *p) p++;
    if (!strnicmp("plugin",p,strlen("plugin")))
    {
      p+=6;
      while (*p<33 && *p) p++;
      fprintf(newini,"plugin %s",MostRecentPlug(p,plugs));
    }
     else
      fprintf(newini,"%s",b);
  }
  for (i=0;i<256;i++)
    if (plugs[i*256]) fprintf(newini,"plugin %s",plugs+i*256);

  fclose(usmini);
  fclose(newini);
  DeleteFile(n1);
  MoveFile(n2,n1);
  return true;
}

bool ImportUsmIni(char*dll,char*upd) 
{
  bool cont=true;
  FILE*f,*usmini;
  char buf1[1024];
  char buf2[1024];
  sprintf(buf1,"%s\\usmtemp.ini",DSTDIR);
  f=fopen(buf1,"w");
  if (!f) 
    return false;
  
  ImportPlugs(); // Import the plugins from the original usm.ini

  sprintf(buf2,"%s\\usm.ini",DSTDIR);
  usmini=fopen(buf2,"r");
  if (!usmini)
  {
    fclose(f);
    oldinstallfailled=1;
    return false;
  }

  char b[1024];
  char*p=b;
  while (fgets(b,1024,usmini))
  {
    p=b;
    while (*p<33 && *p) p++;
    if (!strnicmp("update",p,strlen("update")))
    {
//      MessageBox(NULL,upd,"Changing scol update reference",0);
      fprintf(f,"update %s\n",upd);
    }
    else if (!strnicmp("scol",p,strlen("scol")))
    {
//      MessageBox(NULL,dll,"Changing scol dll reference",0);
      fprintf(f,"scol %s\n",dll);
    }
    else
      fprintf(f,"%s",b);
  }

  fclose(f);
  fclose(usmini);

  DeleteFile(buf2);
  MoveFile(buf1,buf2);

  return true;
}


bool ReplaceFile(char *replace,char *file) 
{
	bool cont=true;
	FILE *f1,*f2;
	char buf1[1024];
	char buf2[1024];

	sprintf(buf1,"%s.temp",file);
	f1=fopen(buf1,"w");
	if (!f1) return false;

	sprintf(buf2,"%s",file);
	f2=fopen(buf2,"r");
	if (!f2)
	{
		fclose(f1);
		return false;
	}

	char b[1024];
	char *p=b;
	char *pat=getvar("Pattern");

	while (fgets(b,1024,f2))
	{
		p=b;
		while (*p<33 && *p) p++;
		if (!strnicmp(pat,p,strlen(pat)))
		{
			fprintf(f1,"%s\n",replace);
		}
		else
		{
			fprintf(f1,"%s",b);
		}
	}

	fclose(f1);
	fclose(f2);

	DeleteFile(buf2);
	MoveFile(buf1,buf2);

	return true;
}




bool ImportOldScol(HWND hwnddialog, char* dll, char* upd)
{
  char buf[MAX_PATH];
  char buf2[MAX_PATH];

  sprintf(buf,"%s\\%s",SRCDIR,"usm.ini");
  sprintf(buf2,"%s\\%s",DSTDIR,"usm.ini");
//  MessageBox(NULL,buf,buf2,0);
  if (exist(buf2)<1)
  {
    iCopyF(hwnddialog, buf, buf2, IFOP_MODE_UNSAFE);
    return ImportUsmpack();
  }
  else
  {
    return ImportUsmIni(dll,upd);
  }
}





/***************************************************/
/*                                                 */
/* scol 4 :                                        */
/*                                                 */
/* iMoveF is now interface to ifopMoveF            */
/* --> ifopCopyF now in iFilesOperations.cpp       */
/*                                                 */ 
/***************************************************/
DWORD iMoveF (HWND hwnddialog, LPCTSTR src, LPCTSTR dst, DWORD mode)
{
	if (src && dst)
	{
		if (!ifopCopyF (src, dst, mode))
		{
		    if (!Silent)
				MsgBox(MainHWND,MB_OK,getvar("ERROR_MOVE_TTL"),getvar("ERROR_MOVE_MSG"),src,dst);
	        StopINI=TRUE;
			StopALL=TRUE;
			oldinstallfailled=1;
			return 0;
		}
		else
		{
			//scol v 4 : progress bar
			if (!DeleteFile (src))
				return -1;
			SetProgressBarPos (hwnddialog, src);
			return 1;
		}
	}
	return 0;
}





/*
int FCopy (char * source[],int n,char * dest,BOOL move,BOOL overwrite)
{
  if (move)
    for (int i=0;i<n;i++) MoveF(source[i],dest);
  else
    for (int i=0;i<n;i++) CopyF(source[i],dest);
  return 0;  
}
*/

void SetText(HWND h,int id,char *format, ...)
{
  va_list arglist;
  char buf[4096];
  MSG msg;

  if (!format) return;
  va_start(arglist,format);
  justify(format);
  vsprintf(buf,format,arglist);
  va_end(arglist);

  SetDlgItemText(h,id,buf);
  if (!Silent)
  {
    InvalidateRect(h,NULL,TRUE);
    UpdateWindow(h);
  }
  if(PeekMessage(&msg,NULL,0,0,PM_REMOVE))
  {
    TranslateMessage(&msg);
    DispatchMessage(&msg);
  }
}

BOOL WriteLicence ()
{
  char file[1024];
  FILE* lic;

  sprintf(file,"%s\\UsmRess.ini",DSTDIR);
  lic=fopen(file,"a+");
  if (!lic) 
  {
		if (!Silent)
			MsgBox(NULL,0,getvar("ERROR_OPEN_TTL"),getvar("ERROR_OPEN_MSG"));
    oldinstallfailled=1;
    return FALSE;
  }

  fseek(lic,0,SEEK_END);
  fprintf(lic,"\nLicense %s",License);
  fclose(lic);

  return TRUE;
}

BOOL WriteForcedIP ()
{
  char file[1024];
  FILE* lic;

  sprintf(file,"%s\\Usm.ini",DSTDIR);
  lic=fopen(file,"a+");
  if (!lic) 
  {
		if (!Silent)
			MsgBox(NULL,0,getvar("ERROR_OPEN_TTL"),getvar("ERROR_OPEN_MSG"));
    oldinstallfailled=1;
    return FALSE;
  }

  fseek(lic,0,SEEK_END);
  fprintf(lic,"\nforcedIP %s\n",ForcedIP);
  fclose(lic);

  return TRUE;
}

BOOL WriteDNSname (char *file)
{
  FILE* lic;

  lic=fopen(file,"a+");
  if (!lic) 
  {
		if (!Silent)
			MsgBox(NULL,0,getvar("ERROR_OPEN_TTL"),getvar("ERROR_OPEN_MSG"));
    oldinstallfailled=1;
    return FALSE;
  }

  fseek(lic,0,SEEK_END);
  fprintf(lic,"\nDNSname %s",DNSname);
  fclose(lic);

  return TRUE;
}

char* filetoshow;

BOOL ShowFile (HWND hwnd,char* file)
{
  filetoshow=file;
  BOOL res=(BOOL)DialogBox(Instance,"LICENCE",hwnd,(DLGPROC)LicenceDlgProc);
  return res;
}


HRESULT CreateLink(LPCSTR lpszPathObj, LPSTR lpszPathLink, LPSTR lpszPathWork, LPSTR lpszArg) 
{ 
  HRESULT hres; 
  IShellLink* psl; 
  ITEMIDLIST * pidl;
  char buf[MAX_PATH];

  // Get a pointer to the IShellLink interface. 
  hres = CoCreateInstance(CLSID_ShellLink, NULL, 
      CLSCTX_INPROC_SERVER, IID_IShellLink, (void**)&psl); 
  if (SUCCEEDED(hres)) 
  { 
    IPersistFile* ppf; 

    // Set the path to the shortcut target, and add the 
    // description. 
    
    psl->SetPath(lpszPathObj); 
    psl->SetWorkingDirectory(lpszPathWork); 
    psl->SetArguments(lpszArg);

   // Query IShellLink for the IPersistFile interface for saving the 
   // shortcut in persistent storage. 
    hres = psl->QueryInterface(IID_IPersistFile, 
        (void**)&ppf); 

    if (SUCCEEDED(hres)) 
    { 
      WORD wsz[MAX_PATH]; 

      SHGetSpecialFolderLocation(MainHWND,CSIDL_PROGRAMS,&pidl);
      SHGetPathFromIDList(pidl,buf);
      strcat(buf,"\\");
      strcat(buf,PROGRAMGROUP);
      strcat(buf,"\\");
      strcat(buf,lpszPathLink);
      strcat(buf,".lnk");
      // Ensure that the string is ANSI. 
      MultiByteToWideChar(CP_ACP, 0, buf, -1, 
          wsz, MAX_PATH); 

      // Save the link by calling IPersistFile::Save. 
      hres = ppf->Save(wsz, TRUE); 
      ppf->Release(); 
    } 
    psl->Release(); 
  } 
  return hres; 
} 

HRESULT CreateStartLink(LPCSTR lpszPathObj, LPSTR lpszPathLink, LPSTR lpszPathWork, LPSTR lpszArg) 
{ 
  HRESULT hres; 
  IShellLink* psl; 
  ITEMIDLIST * pidl;
  char buf[MAX_PATH];

  // Get a pointer to the IShellLink interface. 
  hres = CoCreateInstance(CLSID_ShellLink, NULL, 
      CLSCTX_INPROC_SERVER, IID_IShellLink, (void**)&psl); 
  if (SUCCEEDED(hres)) 
  { 
    IPersistFile* ppf; 

    // Set the path to the shortcut target, and add the 
    // description. 
    
    psl->SetPath(lpszPathObj); 
    psl->SetWorkingDirectory(lpszPathWork); 
    psl->SetArguments(lpszArg);

   // Query IShellLink for the IPersistFile interface for saving the 
   // shortcut in persistent storage. 
    hres = psl->QueryInterface(IID_IPersistFile, 
        (void**)&ppf); 

    if (SUCCEEDED(hres)) 
    { 
      WORD wsz[MAX_PATH]; 

      SHGetSpecialFolderLocation(MainHWND,CSIDL_STARTUP,&pidl);
      SHGetPathFromIDList(pidl,buf);
      strcat(buf,"\\");
      strcat(buf,lpszPathLink);
      strcat(buf,".lnk");
      // Ensure that the string is ANSI. 
      MultiByteToWideChar(CP_ACP, 0, buf, -1, 
          wsz, MAX_PATH); 

      // Save the link by calling IPersistFile::Save. 
      hres = ppf->Save(wsz, TRUE); 
      ppf->Release(); 
    } 
    psl->Release(); 
  } 
  return hres; 
} 

HRESULT CreateDesktopLink(LPCSTR lpszPathObj, LPSTR lpszPathLink, LPSTR lpszPathWork, LPSTR lpszArg, LPSTR lpszIco) 
{
  HRESULT hres; 
  IShellLink* psl; 
  ITEMIDLIST * pidl;
  char buf[MAX_PATH];


  // Get a pointer to the IShellLink interface. 
  hres = CoCreateInstance(CLSID_ShellLink, NULL, 
      CLSCTX_INPROC_SERVER, IID_IShellLink, (void**)&psl); 
  if (SUCCEEDED(hres)) 
  { 
    IPersistFile* ppf; 

    // Set the path to the shortcut target, and add the 
    // description. 
    
    psl->SetPath(lpszPathObj);
    psl->SetWorkingDirectory(lpszPathWork);
	if (lpszArg && strlen(lpszArg))
		psl->SetArguments(lpszArg);
	if (lpszIco && strlen(lpszIco))
		psl->SetIconLocation(lpszIco,0);

   // Query IShellLink for the IPersistFile interface for saving the 
   // shortcut in persistent storage. 
    hres = psl->QueryInterface(IID_IPersistFile, 
        (void**)&ppf); 

    if (SUCCEEDED(hres)) 
    { 
      WORD wsz[MAX_PATH]; 

      SHGetSpecialFolderLocation(MainHWND,CSIDL_DESKTOPDIRECTORY,&pidl);
      SHGetPathFromIDList(pidl,buf);
      strcat(buf,"\\");
      strcat(buf,lpszPathLink);
      strcat(buf,".lnk");
      // Ensure that the string is ANSI. 
      MultiByteToWideChar(CP_ACP, 0, buf, -1, 
          wsz, MAX_PATH); 

      // Save the link by calling IPersistFile::Save. 
      hres = ppf->Save(wsz, TRUE); 
      ppf->Release(); 
    } 
    psl->Release(); 
  } 
  return hres; 
} 

HRESULT DestroyDesktopLink(LPCSTR lpszPathLink) 
{ 
  HRESULT hres; 
  IShellLink* psl; 
  ITEMIDLIST * pidl;
  char buf[MAX_PATH];


  // Get a pointer to the IShellLink interface. 
  hres = CoCreateInstance(CLSID_ShellLink, NULL, 
      CLSCTX_INPROC_SERVER, IID_IShellLink, (void**)&psl); 
  if (SUCCEEDED(hres)) 
  { 
    IPersistFile* ppf; 

   // Query IShellLink for the IPersistFile interface for saving the 
   // shortcut in persistent storage. 
    hres = psl->QueryInterface(IID_IPersistFile, 
        (void**)&ppf); 

    if (SUCCEEDED(hres)) 
    { 
      WORD wsz[MAX_PATH]; 

      SHGetSpecialFolderLocation(MainHWND,CSIDL_DESKTOPDIRECTORY,&pidl);
      SHGetPathFromIDList(pidl,buf);
      strcat(buf,"\\");
      strcat(buf,lpszPathLink);
      strcat(buf,".lnk");
      // Ensure that the string is ANSI. 
      MultiByteToWideChar(CP_ACP, 0, buf, -1, 
          wsz, MAX_PATH); 

      // Save the link by calling IPersistFile::Save. 
//      hres = ppf->Save(wsz, TRUE); 
      DeleteFile(buf);
      ppf->Release(); 
    } 
    psl->Release(); 
  } 
  return hres; 
} 

HRESULT DestroyStartLink(LPCSTR lpszPathLink) 
{ 
  HRESULT hres; 
  IShellLink* psl; 
  ITEMIDLIST * pidl;
  char buf[MAX_PATH];


  // Get a pointer to the IShellLink interface. 
  hres = CoCreateInstance(CLSID_ShellLink, NULL, 
      CLSCTX_INPROC_SERVER, IID_IShellLink, (void**)&psl); 
  if (SUCCEEDED(hres)) 
  { 
    IPersistFile* ppf; 

   // Query IShellLink for the IPersistFile interface for saving the 
   // shortcut in persistent storage. 
    hres = psl->QueryInterface(IID_IPersistFile, 
        (void**)&ppf); 

    if (SUCCEEDED(hres)) 
    { 
      WORD wsz[MAX_PATH]; 

      SHGetSpecialFolderLocation(MainHWND,CSIDL_STARTUP,&pidl);
      SHGetPathFromIDList(pidl,buf);
      strcat(buf,"\\");
      strcat(buf,lpszPathLink);
      strcat(buf,".lnk");
      // Ensure that the string is ANSI. 
      MultiByteToWideChar(CP_ACP, 0, buf, -1, 
          wsz, MAX_PATH); 

      // Save the link by calling IPersistFile::Save. 
//      hres = ppf->Save(wsz, TRUE); 
      DeleteFile(buf);
      ppf->Release(); 
    } 
    psl->Release(); 
  } 
  return hres; 
} 


int Deltree(char * base,char * path)
{
	int res;
	long h;
	struct _finddata_t fileinfo;
	char buf[MAX_PATH];
  bool p=false;

  if (path)
    if (strcmp(path,"")) 
      p=true;

  if (p)
    sprintf(buf,"%s\\%s\\*.*",base,path);
  else
    sprintf(buf,"%s\\*.*",base);

	h=_findfirst(buf,&fileinfo );
	res=h;
	while(res!=-1)
	{
    if (p)
		  sprintf(buf,"%s\\%s\\%s",base,path,fileinfo.name);
    else
		  sprintf(buf,"%s\\%s",base,fileinfo.name);

    if (fileinfo.attrib&16)
		{
			if (strcmp(fileinfo.name,".")&&strcmp(fileinfo.name,".."))
			{
        char buf[MAX_PATH];      
        if (p)
          sprintf(buf,"%s\\%s",path,fileinfo.name);
        else
          sprintf(buf,"\\",fileinfo.name);
        Deltree(base,buf);
			}
		}
		else
      DeleteFile(buf);
		res=_findnext(h,&fileinfo );
	}
  if (p)
    sprintf(buf,"%s\\%s",base,path);
  else
    sprintf(buf,"%s",base,path);
//  _rmdir(buf);
  RemoveDirectory(buf);

	if (h!=-1) _findclose(h);
  return 0;
}

void DeleteAllFiles(char * base,char * path)
{
	int res;
	long h;
	struct _finddata_t fileinfo;
	char buf[MAX_PATH];
  bool p=false;

  if (path)
    if (strcmp(path,"")) 
      p=true;

  if (p)
    sprintf(buf,"%s\\%s\\*.*",base,path);
  else
    sprintf(buf,"%s\\*.*",base);

	h=_findfirst(buf,&fileinfo );
	res=h;
	while(res!=-1)
	{
    if (p)
		  sprintf(buf,"%s\\%s\\%s",base,path,fileinfo.name);
    else
		  sprintf(buf,"%s\\%s",base,fileinfo.name);

//    MessageBox(NULL,"deleting",buf,0);
    DeleteFile(buf);
		res=_findnext(h,&fileinfo );
	}
  if (p)
    sprintf(buf,"%s\\%s",base,path);
  else
    sprintf(buf,"%s",base,path);

	if (h!=-1) _findclose(h);
}

void ShowWin()
{
  if (!Silent)
    TOPShowWindow(MainHWND,SW_SHOWNORMAL);
}

void HideWin()
{
  ShowWindow(MainHWND,SW_HIDE);
}


void CreateGroup(char * name)
{
  ITEMIDLIST * pidl;
  char buf[MAX_PATH];

  SHGetSpecialFolderLocation(MainHWND,CSIDL_PROGRAMS,&pidl);
  SHGetPathFromIDList(pidl,buf);
  strcat(buf,"\\");
  strcat(buf,name);
  _mkdir(buf);
//  MessageBox(0,buf,"Programs stored in:",0);
}

void DestroyGroup(char * name)
{
  ITEMIDLIST * pidl;
  char buf[MAX_PATH];

  SHGetSpecialFolderLocation(MainHWND,CSIDL_PROGRAMS,&pidl);
  SHGetPathFromIDList(pidl,buf);
  strcat(buf,"\\");
  strcat(buf,name);
  Deltree(buf,NULL);
  _rmdir(buf);
}


/*int MessageIt (char * title,char * msg,void * perso)
{
  MsgBox(MainHWND,NULL,msg,title);
  return 0;
}*/
    
int FindApplyFile(HWND hDlg,char *path,char *name,char*section)
{
	int res;
	long h;
	struct _finddata_t fileinfo;
	char buf[MAX_PATH];
  static HWND hwnddialog;

  if (hDlg)
  {
    hwnddialog=(HWND)CreateDialog(Instance,"WAITER",hDlg,(DLGPROC)WaiterDlgProc);
    if (!Mini && !Silent)
      TOPShowWindow(hwnddialog,SW_SHOWNORMAL);
    if (Silent)
      ShowWindow(hwnddialog,SW_HIDE);
  }

  SetText(hwnddialog,WAITER_TEXT,getvar("SEARCHING_FILES_MSG"),path);

  if (!name)
    name="*.*";

  sprintf(buf,"%s\\*.*",path);

	h=_findfirst(buf,&fileinfo );
	res=h;
	while(res!=-1)
	{
		sprintf(buf,"%s\\%s",path,fileinfo.name);
		if (fileinfo.attrib&16)
		{
			if (strcmp(fileinfo.name,".")&&strcmp(fileinfo.name,".."))
			{
        FindApplyFile(NULL,buf,name,section);
			}
		}
		else
		{
      if (!strcmp(fileinfo.name,name))
      {
        setvar("DSTDIR",path);
        ProcessIniFile(hwnddialog,section);
      }

		}
		res=_findnext(h,&fileinfo );
	}
	if (h!=-1) _findclose(h);
  if (hDlg) EndDialog(hwnddialog,0);
  return 0;
}


int SearchInDrives(HWND hDlg,char * fname,char* section)
{
	int res,n=0;
  char name[1024];
  MSG msg;
/*  HTREEITEM h;*/

  strcpy(name,"a:");
  *name='a';
	res=GetLogicalDrives();
	while(res)
	{
    n=GetDriveType(name);
		if (res&1 &&
        n!=DRIVE_UNKNOWN &&
        n!=DRIVE_REMOVABLE &&
        n!=DRIVE_CDROM &&
        n!=DRIVE_RAMDISK &&
        n!=DRIVE_REMOTE
        )
		{
      FindApplyFile(hDlg,name,fname,section);
    }
    *name+=1;
		res>>=1;
    if (!Silent)
      UpdateWindow(MainHWND);
    if(PeekMessage(&msg,NULL,0,0,PM_REMOVE))
    {
      TranslateMessage(&msg);
      DispatchMessage(&msg);
    }
	}
  return 0;
}




int CopyDirToDest(HWND hdlg,char * base,char * path, DWORD mode)
{
	int res;
	long h;
	struct _finddata_t fileinfo;
  MSG msg;
	char buf[MAX_PATH];

//  MsgBox(MainHWND,NULL,"MkDIR+copy","in %s , make %s",DSTDIR,path);
  sprintf(buf,"%s\\%s",DSTDIR,path);
  _mkdir(buf);

  sprintf(buf,"%s\\%s\\*.*",base,path);

	h=_findfirst(buf,&fileinfo );
	res=h;
	while(res!=-1)
	{
		sprintf(buf,"%s\\%s\\%s",base,path,fileinfo.name);
    SetText(hdlg,WAITER_TEXT,getvar("COPY_MSG"),fileinfo.name);
		if (fileinfo.attrib&16)
		{
			if (strcmp(fileinfo.name,".")&&strcmp(fileinfo.name,".."))
			{
        char buf[MAX_PATH];      
        sprintf(buf,"%s\\%s",path,fileinfo.name);
        if (CopyDirToDest(hdlg, base, buf, mode)<0) return -1;
			}
		}
		else
		{
      char buf [MAX_PATH];
      char buf2[MAX_PATH];

      sprintf(buf ,"%s\\%s\\%s",base,path,fileinfo.name);
      sprintf(buf2,"%s\\%s\\%s",DSTDIR,path,fileinfo.name);
//      MsgBox(MainHWND,NULL,"CopyFile","From %s to %s",buf,buf2);
      iCopyF(hdlg, buf,buf2, mode);
    }
    if(PeekMessage(&msg,NULL,0,0,PM_REMOVE))
    {
      TranslateMessage(&msg);
      DispatchMessage(&msg);
    }
		res=_findnext(h,&fileinfo );
	}
	if (h!=-1) _findclose(h);
  return 0;
}

void LaunchExe (char* p,char *n,char * args)
{
   ShellExecute(NULL,"open",n,args,p,SW_SHOWDEFAULT);
}

int LaunchExeWait (char *n,char ** args)
{
//  return _spawnvp( _P_WAIT,n,args);
  return _spawnl( _P_WAIT,n,"x.exe",args[0],NULL);
}

BOOL RegisterActiveX (LPSTR DllName)
{
  FARPROC lpDllEntryPoint;
  HINSTANCE hLib=LoadLibrary(DllName);

  if (hLib<(HINSTANCE)HINSTANCE_ERROR)
  {
		Error (getvar("ERROR_LOAD_DLL"),DllName);
    oldinstallfailled=1;
    return FALSE;
  }
  (FARPROC&)lpDllEntryPoint=GetProcAddress(hLib,"DllRegisterServer");
  if (lpDllEntryPoint!=NULL)
    (*lpDllEntryPoint)();
  else
  {
    Error(getvar("ERROR_REG_DLL"),DllName);
    FreeLibrary(hLib);
    oldinstallfailled=1;
    return FALSE;
  }
  FreeLibrary(hLib);
  return TRUE;
}

BOOL UnRegisterActiveX (LPSTR DllName)
{
  FARPROC lpDllEntryPoint;
  HINSTANCE hLib=LoadLibrary(DllName);

  if (hLib<(HINSTANCE)HINSTANCE_ERROR)
  {
    Error (getvar("ERROR_LOAD_DLL"),DllName);
    oldinstallfailled=1;
    return FALSE;
  }
  (FARPROC&)lpDllEntryPoint=GetProcAddress(hLib,"DllUnregisterServer");
  if (lpDllEntryPoint!=NULL)
    (*lpDllEntryPoint)();
  else
  {
    Error(getvar("ERROR_UREG_DLL"),DllName);
    FreeLibrary(hLib);
    oldinstallfailled=1;
    return FALSE;
  }
  FreeLibrary(hLib);
  return TRUE;
}

char* passBlank (char*code)
{
  while (*code)
  {
    if (*code<=32) code++;
    else return code;
  }
  return code;
}

int INIGetWord(char*pat1,char*pat2,FILE* f)
{
  char*ptr;
  char line[1024]; 
  int t=0;

  if (feof(f)) return 0;
  while (!feof(f))
  {
    t=0;
    fgets(line,1024,f);
//    MessageBox(NULL,line,"getusmpackline:",0);
    
	ptr=passBlank(line);
    while (ptr[t]>32) t++;
    ptr[t]=0;

    if (pat1)
      if (!stricmp(ptr,pat1))
        return 1;
    if (pat2)
      if (!stricmp(ptr,pat2))
        return 2;
  }
  return 0;
}

BOOL SetPrivilege(
    HANDLE hToken,          // access token handle
    LPCTSTR lpszPrivilege,  // name of privilege to enable/disable
    BOOL bEnablePrivilege   // to enable or disable privilege
    ) 
{
  TOKEN_PRIVILEGES tp;
  LUID luid;

  if ( !LookupPrivilegeValue( 
          NULL,            // lookup privilege on local system
          lpszPrivilege,   // privilege to lookup 
          &luid ) ) 
  {      // receives LUID of privilege
    printf("LookupPrivilegeValue error: %u\n", GetLastError() ); 
    return FALSE; 
  }

  tp.PrivilegeCount = 1;
  tp.Privileges[0].Luid = luid;
  if (bEnablePrivilege)
    tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
  else
    tp.Privileges[0].Attributes = 0;

  // Enable the privilege or disable all privileges.

  AdjustTokenPrivileges(
         hToken, 
         FALSE, 
         &tp, 
         sizeof(TOKEN_PRIVILEGES), 
         (PTOKEN_PRIVILEGES) NULL, 
         (PDWORD) NULL); 
 
  // Call GetLastError to determine whether the function succeeded.

  if (GetLastError() != ERROR_SUCCESS) 
  { 
    printf("AdjustTokenPrivileges failed: %u\n", GetLastError() ); 
    return FALSE; 
  } 

  return TRUE;
}










/* récupère la première ligne
retourne un pointeur vers la ligne suivante ou NULL si terminé ou erreur*/
char *stdGetLine(char *src,char *buf,int n)
{
  int c,i;

  while((c=(*(src++)))<32) if (c==0) return NULL;
  i=0;
  buf[i++]=c;
  while(((c=(*(src++)))>=32)&&(c)&&(i<n)) buf[i++]=c;
  if (c==0) src--;
  if (i==n) return NULL;
  buf[i]=0;
  return src;
}

/* decoupage d'une chaine en mots (retourne le nombre de mots)
 format strbuild */
int strCutting(char *comm, char **argv)
{
  int i,j,k,argc;
  
  i=0;
  j=-1;
  argc=0;

  while(comm[i])
  {
	  if (comm[i]==32)
	  {
		  if (j>=0) comm[j]=0;
		  j=-1;
		  i++;
	  }
	  else
	  {
		  if (j==-1)
		  {
			  j=i;
			  argv[argc++]=&comm[i];
		  }
		  if (comm[i]=='\\')
		  {
			  i++;
              if ((comm[i]>='0')&&(comm[i]<='9'))
			  {
				  k=comm[i]-'0';
				  i++;
				  if ((comm[i]>='0')&&(comm[i]<='9'))
				  {
					  k=k*10+comm[i]-'0';
					  i++;
					  if ((comm[i]>='0')&&(comm[i]<='9'))
					  {
						  k=k*10+comm[i]-'0';
						  i++;
					  }
				  }
				  comm[j++]=k;
			  }
			  else if (comm[i]=='n')
			  {
				  comm[j++]=10;
				  i++;
			  }
			  else if (comm[i]=='z')
			  {
				  comm[j++]=0;
				  i++;
			  }
			  else
			  {
				  comm[j++]=comm[i];
				  if (comm[i]) i++;
			  }
		  }
		  else comm[j++]=comm[i++];
	  }
  }
  if (j>=0) comm[j]=0;
  return argc;
}


/* decoupage d'une chaine en mots (retourne le nombre de mots)
 conserve les '\' contrairement à strCutting() */
int strCuttingLine(char *comm, char **argv)
{
  int i,j,argc;
  
  i=0;
  j=-1;
  argc=0;

  while(comm[i])
  {
	  if (comm[i]==32)
	  {
		  if (j>=0) comm[j]=0;
		  j=-1;
		  i++;
	  }
	  else
	  {
		  if (j==-1)
		  {
			  j=i;
			  argv[argc++]=&comm[i];
		  }
		  if (comm[i]=='\\')
		  {
			  comm[j++]=comm[i++];
			  if (comm[i])
				comm[j++]=comm[i++];
		  }
		  else comm[j++]=comm[i++];
	  }
  }
  if (j>=0) comm[j]=0;
  return argc;
}


int IsScolUpdated (char* usmini,char* update)
{
	FILE *f;
	char *line;
  char buf[512];
  char* argv[128];
  char srcbuf[2048];
  int n;

  if (oldinstallfailled)
    return 0;

	if (f=fopen(usmini,"rb"))
	{
		srcbuf[fread(srcbuf,1,2047,f)]=0;
		fclose(f);
		line=srcbuf;
		while(line=stdGetLine(line,buf,512))
		{
			if (n=strCutting(buf,argv))
			{
				if ((n>1)&&(!strcmpi(argv[0],"update")))
				{
//          char b[512];
//          MessageBox (NULL,argv[1],usmini,0);
//          sprintf(b,"Value: %s , %s  = %d", argv[1], update,strcmp(argv[1],update));
          if (!strcmpi(argv[1],"auto")) return 0;
          if (!strcmpi(argv[1],"no")) return 1;
			    return (strcmpi(argv[1],update)>=0);
				}
			}
		}
	}
	return 0;
}

void ascii2scol(char*src,char*dst)
{
  while (*src)
  {
    if (*src>32 && *src<=127 && *src!='\\')
      *dst++=*src++;
    else if (*src=='\\' || *src==' ')
    {
      *dst++='\\';
      *dst++=*src++;
    }
    else if (*src==10)
    {
      *dst++='\\';
      *dst++='n';
      *src++;
    }
    else
    {
      sprintf(dst,"\\%3d",*src++);
      dst+=4;
    }
  }
  *dst=0;
}

int SetSettings()
{
  char buf[MAX_PATH];
  char buf2[MAX_PATH];
  FILE*f;

  sprintf(buf,"%s\\usmress.ini",DSTDIR);
  f=fopen(buf,"a+t");
  if (!f)
  {
		if (!Silent) {
			sprintf(buf2,getvar("ERROR_OPEN_MSG"),buf);
			MsgBox(NULL,NULL,getvar("ERROR_OPEN_MSG"),buf2);
		}
    return FALSE;
  }

  fprintf(f,"\nDefaultLanguage %s",GetLangName(langid));
  fprintf(f,"\nRegistering Yes");

  fclose(f);
  return TRUE;
}

void delBracket (char*ptr)
{
  while (*ptr!=']' && *ptr) ptr++;
  *ptr=0;
}

void getCode (char**ptr,int*i)
{
  int t=0,j;
  
  while ((*ptr)[t]>32) t++;
  (*ptr)[t]=0;

  for (j=0;j<N_OP;j++) 
  {
    if (!stricmp(*ptr,Operations[j].syntax)) 
    {
      (*ptr)+=t+1;
      (*i)=Operations[j].code;
      return;
    }
  }
  *i=-1;
}

BOOL getToken (char**ptr,char**token)
{
  int t=0;
  
  if ((*ptr)[t]=='"')
  {
    (*ptr)++;
    (*token)=(*ptr);
    while ((*ptr)[t]!='"' && (*ptr)[t]) t++;
    (*ptr)[t]=0;
    (*ptr)+=t+1;
    return FALSE;
  }
  else
  {
    while ((*ptr)[t]>32) t++;
    (*ptr)[t]=0;
    (*token)=(*ptr);
    (*ptr)+=t+1;
    return TRUE;
  }
}

int INIGetLine(char* line,int n,FILE* f)
{
  if (feof(f)) return 1;
  fgets(line,n,f);
  if ((line)[0]=='[') return 1;

  return 0;
}

int INIGetSection(char*pat,FILE* f)
{
  char*ptr;
  char line[1024]; 

  if (feof(f)) return 0;
  while (!feof(f))
  {
    fgets(line,1024,f);
    ptr=passBlank(line);
    if (ptr[0]=='[') 
    {
      ptr++;
      delBracket(ptr);
      if (!stricmp(ptr,pat))
        return 1;
    }
  }
  return 0;
}

int IsGreater(char *str1, char *str2)
{
	return (strcmp(str1,str2)>0 ? 1 : 0);
}

void lPad(char *str, char c, size_t len)
{
	char *buf;

	if (strlen(str)<len) {
		buf=(char*)malloc(len+1);
		if (!buf) return;
		memset(buf,c,len-strlen(str));
		strcpy(buf+len-strlen(str),str);
		strcpy(str,buf);
		free(buf);
	}
	return;
}

void GetVersion(char *file, char *key)
{
	FILE* f;
	char line[1024];
	char* argv[128];
	char num[5];
	char res[128];
	int narg,i;

	setvar("MAJMIN","0000-0000");
	f=fopen(file,"rt");
	if (!f) return;

	while (!feof(f))
	{
		fgets(line,1024,f);
		if ((narg=strCutting(line,argv))>2) {
			if (!stricmp(argv[0],key)) {
				fclose(f);
				if (strlen(argv[narg-1])) {
					if (argv[narg-1][strlen(argv[narg-1])-1]=='\n') {
						argv[narg-1][strlen(argv[narg-1])-1]='\0';
					}
				}
				res[0]='\0';
				for (i=1 ; i<narg ; i++) {
					memset(num,0,sizeof(num));
					strncpy(num,argv[i],sizeof(num)-1);
					lPad(num,'0',sizeof(num)-1);
					if (strlen(res)) {
						strcat(res,"-");
					}
					strcat(res,num);
				}
				setvar("MAJMIN",res);
				return;
			}
		}
	}
	fclose(f);
	return;
}

int SearchInFile(char*pat,char*file)
{
  char*ptr;
  FILE* f;
  char line[1024]; 
  char* argv[128];
  char temp[20];
  int n,i;
  MSG msg;

  f=fopen(file,"rt");
  if (!f) return 0;

  while (!feof(f))
  {
    fgets(line,1024,f);
    ptr=passBlank(line);
	setvar("LineFound","");
    if (!strnicmp(ptr,pat,strlen(pat)))
    {  
	  if (line[strlen(line)-1]=='\n') line[strlen(line)-1]='\0';
	  setvar("LineFound",line);
	  n=strCuttingLine(line,argv);
	  for (i=0 ; i<n ; i++)
	  {
		sprintf(temp,"WordFound%d",i);
		setvar(temp,argv[i]);
	  }
	  for (i=n ; i<10 ; i++)
	  {
		sprintf(temp,"WordFound%d",i);
		setvar(temp,"");
	  }
      fclose(f);
      return 1;
    }
    if(PeekMessage(&msg,NULL,0,0,PM_REMOVE))
    {
      TranslateMessage(&msg);
      DispatchMessage(&msg);
    }
  }
  fclose(f);
  return 0;
}

int ParseFile(char*file,char*section)
{
	FILE *f;
	char *line;
	char buf[512];
	char tempbuild[512];
	char temp[20];
	char* argv[128];
	char *srcbuf;
	int size,n,i;
	char *ptr;

	if (f=fopen(file,"rb"))
	{
		fseek(f,0,SEEK_END);
		size=ftell(f);
		fseek(f,0,SEEK_SET);
		srcbuf=(char*)malloc(size+1);
		if (!srcbuf)
		{
			fclose(f);
			return 0;
		}
		srcbuf[fread(srcbuf,1,size,f)]=0;
		fclose(f);
		line=srcbuf;
		while(line=stdGetLine(line,buf,512))
		{
			setvar("TempLine",buf);
			ptr=passBlank(buf);
			setvar("TempStripped",ptr);
			tempbuild[0]=0;
			if (n=strCutting(buf,argv))
			{
				strcat(tempbuild,argv[0]);
				setvar("TempWord0",argv[0]);
			}
			for (i=1 ; i<n ; i++)
			{
				sprintf(temp,"TempWord%d",i);
				setvar(temp,argv[i]);
				strcat(tempbuild," ");
				strcat(tempbuild,argv[i]);
			}
			for (i=n ; i<10 ; i++)
			{
				sprintf(temp,"TempWord%d",i);
				setvar(temp,"");
			}
			setvar("TempBuildLine",tempbuild);
			ProcessIniFile(NULL,section);
		}
		free(srcbuf);
	}
	return 0;
}

int INIGetSectionFromStart(char*pat,FILE* f)
{
  char*ptr;
  char line[1024]; 

  fseek(f,0,SEEK_SET);
  if (feof(f)) return 0;
  while (!feof(f))
  {
    fgets(line,1024,f);
    ptr=passBlank(line);
    if (ptr[0]=='[') 
    {
      ptr++;
      delBracket(ptr);
      if (!stricmp(ptr,pat))
        return 1;
    }
  }
  return 0;
}

int ProcessFile (HWND hwnddialog,FileOperation f)
{
  char buf[MAX_PATH];
  char buf2[MAX_PATH];

  switch (f.code)
  {
  case ICREATEDIR: 
    if (f.source) strcpy(buf,f.source);
    else strcpy(buf,"");
    strcat(buf,"\\");
    if (f.dest) strcat(buf,f.dest);
    SetText(hwnddialog,WAITER_TEXT,getvar("CREATING_DIR_MSG"),buf);
    switch (_mkdir(buf))
    {
    case EACCES:
      // Il existe deja...
      break;
    case ENOENT:
			if (!Silent)
				MsgBox(MainHWND,NULL,getvar("ERROR_COPY_TTL"),getvar("ERROR_CRDIR_MSG"),buf);
      CoUninitialize();
      EndDialog(hwnddialog,0);
      if (!oldinstallfailled) 
        DelSemaphore();
	  iRemoveNeedReboot();
      PostQuitMessage(1);
      return 0;
      break;
    }
    break;




/**********************************************/
/*                                            */
/* file copy functions                        */
/*                                            */
/**********************************************/

  case ICOPYA:
    SetText(hwnddialog,WAITER_TEXT,getvar("COPY_MSG"),f.dest);
    iCopyF(hwnddialog, f.source,f.dest, IFOP_MODE_UNSAFE);
    break;


  case ICOPY:
    sprintf(buf,"%s\\%s",SRCDIR, f.source);
    if (f.dest) sprintf(buf2,"%s\\%s", DSTDIR, f.dest);
    else sprintf(buf2,"%s\\%s", DSTDIR, f.source);

    SetText(hwnddialog,WAITER_TEXT,getvar("COPY_MSG"),buf2);

    iCopyF(hwnddialog, buf, buf2, IFOP_MODE_UNSAFE);
    break;


  case ICOPYS:
    sprintf(buf,"%s\\%s",SRCDIR,f.source);
    sprintf(buf2,"%s\\%s",f.dest,f.source);
    SetText(hwnddialog,WAITER_TEXT,getvar("COPY_MSG"),buf2);
    iCopyF(hwnddialog, buf,buf2, IFOP_MODE_UNSAFE);
    break;


  case ICOPYD:
    sprintf(buf,"%s",f.source);
    sprintf(buf2,"%s\\%s",DSTDIR,f.dest);
    SetText(hwnddialog,WAITER_TEXT,getvar("COPY_MSG"),buf2);
    iCopyF(hwnddialog, buf,buf2, IFOP_MODE_UNSAFE);
    break;


  case ICOPYSAFE:
    sprintf(buf,"%s\\%s",SRCDIR, f.source);
    if (f.dest) sprintf(buf2,"%s\\%s", DSTDIR, f.dest);
    else sprintf(buf2,"%s\\%s", DSTDIR, f.source);

    SetText(hwnddialog,WAITER_TEXT,getvar("COPY_MSG"),buf2);

    iCopyF(hwnddialog, buf, buf2, IFOP_MODE_SAFE);
    break;







/**********************************************/
/*                                            */
/* files move function                        */
/*                                            */
/**********************************************/

  case IMOVEA:
    SetText(hwnddialog,WAITER_TEXT,getvar("MOVE_MSG"),f.source);
    iMoveF(hwnddialog, f.source,f.dest, IFOP_MODE_UNSAFE);
    break;

  case IMOVE:
    sprintf(buf,"%s\\%s",SRCDIR,f.source);
    if (f.dest) sprintf(buf2,"%s\\%s",DSTDIR,f.dest);
    else sprintf(buf2,"%s\\%s",DSTDIR,f.source);
    SetText(hwnddialog,WAITER_TEXT,getvar("MOVE_MSG"),buf2);
    iMoveF(hwnddialog,buf,buf2, IFOP_MODE_UNSAFE);
    break;

  case IMOVES:
    sprintf(buf,"%s\\%s",SRCDIR,f.source);
    sprintf(buf2,"%s\\%s",f.dest,f.source);
    SetText(hwnddialog,WAITER_TEXT,getvar("MOVE_MSG"),buf2);
    iMoveF(hwnddialog,buf,buf2, IFOP_MODE_UNSAFE);
    break;

  case IMOVED:
    sprintf(buf,"%s",f.source);
    sprintf(buf2,"%s\\%s",DSTDIR,f.dest);
    SetText(hwnddialog,WAITER_TEXT,getvar("MOVE_MSG"),buf2);
    iMoveF(hwnddialog,buf,buf2, IFOP_MODE_UNSAFE);
    break;

  case IMOVESAFE:
    sprintf(buf,"%s\\%s",SRCDIR,f.source);
    if (f.dest) sprintf(buf2,"%s\\%s",DSTDIR,f.dest);
    else sprintf(buf2,"%s\\%s",DSTDIR,f.source);
    SetText(hwnddialog,WAITER_TEXT,getvar("MOVE_MSG"),buf2);
    iMoveF(hwnddialog,buf,buf2, IFOP_MODE_SAFE);
    break;







  case ICOPYDIRTODEST:
    CopyDirToDest(hwnddialog,SRCDIR,f.source, IFOP_MODE_UNSAFE);
    break;

  case ICOPYDIRTODESTSAFE:
    CopyDirToDest(hwnddialog,SRCDIR,f.source, IFOP_MODE_SAFE);
    break;


/* scol v 4 : doesn't need this anymore
  case IREGISTER:
    sprintf(buf,"%s\\%s",DSTDIR,f.source);
    SetText(hwnddialog,WAITER_TEXT,getvar("REGISTERING_MSG"),buf);
    RegisterActiveX(buf);
    break;
*/
  //$ LB (28/08/2001) : separate Netscape and Netscape6 management
  case IEnumNetscape6Paths:
	  LastResult= EnumNetscape6Paths (f.source);
	  break;

  case ICREATEGROUP:
    SetText(hwnddialog,WAITER_TEXT,getvar("CREATEPGMGROUP_MSG"),f.source);
    if (f.source) CreateGroup(f.source);
    break;
  case ICREATELINK:
	SetText(hwnddialog,WAITER_TEXT,getvar("CREATELINK_MSG"),f.dest);
	if (f.source && DSTDIR && f.dest)
	{
		sprintf(buf,"%s\\%s",DSTDIR,f.source);
		CreateLink(buf,f.dest,DSTDIR,getvar("LINKARG"));
		setvar("LINKARG","");
	}
    break;
  case ICREATESRCLINK:
	SetText(hwnddialog,WAITER_TEXT,getvar("CREATELINK_MSG"),f.dest);
	if (f.source && SRCDIR && f.dest)
	{
	    sprintf(buf,"%s\\%s",SRCDIR,f.source);
		CreateLink(buf,f.dest,DSTDIR,getvar("LINKARG"));
		setvar("LINKARG","");
	}
    break;
  case ICreateStartLink:
	SetText(hwnddialog,WAITER_TEXT,getvar("CREATELINK_MSG"),f.dest);
	if (f.source && DSTDIR && f.dest)
	{
		sprintf(buf,"%s\\%s",DSTDIR,f.source);
		CreateStartLink(buf,f.dest,DSTDIR,getvar("LINKARG"));
		setvar("LINKARG","");
	}
    break;
  case ICreateDesktopLink:
	SetText(hwnddialog,WAITER_TEXT,getvar("CREATELINK_MSG"),f.dest);
	if (f.source && DSTDIR && f.dest)
	{
		sprintf(buf,"%s\\%s",DSTDIR,f.source);
		CreateDesktopLink(buf,f.dest,DSTDIR,getvar("LINKARG"),getvar("LINKICO"));
		setvar("LINKARG","");
		setvar("LINKICO","");
	}
    break;
  case IDestroyDesktopLink:
    DestroyDesktopLink(f.source);
    break;
  case IDestroyStartLink:
    DestroyStartLink(f.source);
    break;
  case IADDPACK:
    {
      char file[1024];
      FILE* lic;

      sprintf(file,"%s\\Usm.ini",DSTDIR);
      SetFileAttributes(file,FILE_ATTRIBUTE_NORMAL);

//        _chmod(file,_S_IWRITE);
      lic=fopen(file,"a+");
      if (!lic) 
      {
				if (!Silent)
					MsgBox(NULL,NULL,getvar("ERROR_OPEN_TTL"),getvar("ERROR_OPEN_MSG"));
        return FALSE;
      }     
      fseek(lic,0,SEEK_END);
      fprintf(lic,"\ndisk %s\\part2\\ 0\n",f.source);
      fclose(lic);
    }
    break;
  case ISERIAL:
    WriteLicence ();
    break;
  case ISetForcedIP:
    WriteForcedIP ();
    break;
  case ISetDNSname:
    WriteDNSname (f.source);
    break;
  case ISet:           //,"Set",2},
    if (!strcmp(f.srcval,"SETUPNAME") && !Mini) InvalidateRect(MainHWND,NULL,FALSE);
    setvar(f.srcval,f.dest);
    break;
  case IGet:           //,"Get",2},
    if (f.src)
      getvar(f.srcval);
    break;
  case IGoto:          //,"Goto",1},
    ProcessIniFile(hwnddialog,f.source);
    break;

  case IQuit:          //,"Quit",2}  
    if (!Silent)
      MsgBox(hwnddialog,NULL,f.dest,f.source);

	iRemoveNeedReboot();
    EndDialog(hwnddialog,0);
    StopINI=TRUE;
    StopALL=TRUE;
    break;

  case IQuitErr:          //,"Quit",2}  
    if (!Silent) 
	{
		MsgBox(hwnddialog,NULL,f.dest,f.source);
		oldinstallfailled=1;
	}
	iRemoveNeedReboot();
    EndDialog(hwnddialog,0);
    StopINI=TRUE;
    StopALL=TRUE;
    break;

  case IShowFile:
    if (!Silent) LastResult=ShowFile (hwnddialog,f.source);
    else LastResult=1;
    break;
  case IGetSerial:
    LastResult=DialogBox(Instance,"SERIALNUMBER",hwnddialog,(DLGPROC)SerialNumberDlgProc);
    if (!LastResult)
    {
	  MsgBox(MainHWND,NULL,SETUPNAME,getvar("ABORT_MSG"),NULL);
      EndDialog(hwnddialog,0);
      StopINI=TRUE;
      StopALL=TRUE;
      return TRUE;
    }
    break;
  case IGetForcedIP:
    LastResult=DialogBox(Instance,"FORCEDIP",hwnddialog,(DLGPROC)ForcedIPDlgProc);
    if (!LastResult)
    {
	  MsgBox(MainHWND,NULL,SETUPNAME,getvar("ABORT_MSG"),NULL);
      EndDialog(hwnddialog,0);
      StopINI=TRUE;
      StopALL=TRUE;
      return TRUE;
    }
    break;
  case IGetSystemVars:
    GetSystemVars();
    break;
  case IShowInstallDlg:
    if (!Silent && Installdir[0]==0)
    {
      #ifdef BITMAPS
      LastResult=DialogBox(0,"StartInstall",hwnddialog,(DLGPROC)DlgProc);
      #else 
      LastResult=DialogBox(0,"StartInstallNB",hwnddialog,(DLGPROC)DlgProc);
      #endif   
      if (LastResult<0) MsgBox(hwnddialog,NULL,getvar("ERROR_TTL"),getvar("ERROR_DIALOG_MSG"));
    }
    else
      LastResult=1;
    break;
  case IIf:
    if (!LastResult)
    {
      LastResult=INIGetWord("Else","Endif",INIFile);
      if (!LastResult)
      {
        Error(getvar("ERROR_SYNTAX"),"else/endif");
        oldinstallfailled=1;
        StopINI=TRUE;
      }
    }
    break;
  case IIfPos:
    if (LastResult<=0)
    {
      LastResult=INIGetWord("Else","Endif",INIFile);
      if (!LastResult)
      {
        Error(getvar("ERROR_SYNTAX"),"else/endif");
        oldinstallfailled=1;
        StopINI=TRUE;
      }
    }
    break;
  case IElse:
    LastResult=INIGetWord("Endif",0,INIFile);
    if (!LastResult)
    {
      Error(getvar("ERROR_SYNTAX"),"endif");
      oldinstallfailled=1;
      StopINI=TRUE;
    }
    break;
  case IEndif:
    break;
  case IExist:
    {
      WIN32_FIND_DATA FindFileData;
      HANDLE h=FindFirstFile(f.source,&FindFileData);
      if (h!=INVALID_HANDLE_VALUE)
      {
        LastResult=1;
        FindClose(h);
      }
      else
        LastResult=0;
    }
    break;

  //scol 4 : 
  //ApplyOnFiles --> EnumNetscapePaths
  case IEnumNetscapePaths:
    LastResult= EnumNetscapePaths (f.source);
    break;

  // IEnumNetscape6Paths is in 9th position

  case IReturn:
    {
       LastResult=0;
       StopINI=TRUE;
    }
    break;
  case IMsgBoxOK:
//    _asm { int 3 };
    if (!Silent)
      LastResult=MsgBox(hwnddialog,NULL,f.dest,f.source);
    break;
  case IMsgBoxOKCancel:
      if (!Silent)
      {
        if (MsgBox(hwnddialog,MB_OKCANCEL,f.dest,f.source)==IDOK)
          LastResult=1;
        else
          LastResult=0;
      }
    break;
  case IMsgBoxYESNO:
    if (!Silent)
    {
      if (MsgBox(hwnddialog,MB_YESNO,f.dest,f.source)==IDYES)
        LastResult=1;
      else
        LastResult=0;
    }
    break;
  case IDetectTCPIP:
    LastResult=DetectTCPIP();
    break;
  case IStrcat:
    {
      char *b=(char*)malloc(strlen(f.source)+strlen(f.dest)+1);
      if (b)
      {
        strcpy(b,f.source);
        strcat(b,f.dest);
        setvar(f.srcval,b);
        free (b);
      }
    }
    break;
  case IStrcmp:
//    LastResult=strncmp(f.source,f.dest,strlen(f.dest));
    LastResult=strcmp(f.source,f.dest);
    break;
  case IIntcmp:
    LastResult=atoi(f.source)-atoi(f.dest);
    break;
  case IStricmp:
//    LastResult=strnicmp(f.source,f.dest,strlen(f.dest));
    LastResult=stricmp(f.source,f.dest);
    break;
  case IRun:
    LaunchExe (DSTDIR,f.source,f.dest);
    break;
  case IRunWait:
    {
      char *args[2];
      args[0]=f.dest;
      args[1]=NULL;
//      _chdir(DSTDIR);
      LastResult=LaunchExeWait (f.source,args);
//      _chdir(SRCDIR);
    }
    break;
  case IDelete:
    strcpy (buf,"");
    if (f.dest)
    {
      if (*f.dest)
      {
        strcpy (buf,f.dest);
        strcat (buf,"\\");
      }
    }
    strcat(buf,f.source);
    DeleteFile(buf);
    break;
  case IDeleteAllFiles:
    DeleteAllFiles(f.source,NULL);
    break;
  case IUnregister:
    strcpy (buf,"");
    if (f.dest)
    {
      if (*f.dest)
      {
        strcpy (buf,f.dest);
        strcat (buf,"\\");
      }
    }
    strcat (buf,f.source);
    UnRegisterActiveX(buf);
    break;
  case IDeltree:
    Deltree(f.source,f.dest);
    break;
  case IGetPgmGroup:
    {
      ITEMIDLIST * pidl;
      char buf[MAX_PATH];

      SHGetSpecialFolderLocation(MainHWND,CSIDL_PROGRAMS,&pidl);
      SHGetPathFromIDList(pidl,buf);
      setvar(f.srcval,buf);
    }
    break;
  case IDelPgmGroup:
    DestroyGroup(f.source);
    break;
  case IRegisterFont:  
    AddFontResource(f.source);
    break;
  case IUnregisterFont:
    RemoveFontResource(f.source);
    break;
  case IFindInFile:
    LastResult=SearchInFile(f.source,f.dest);
    break;
  case IParseFile:
    ParseFile(f.source,f.dest);
    break;
  case IDetectSCOL:
    {
      char MyPath[1024],*path;
      long msize=1024,i;
      LastResult=1;
      setvar("SCOLpath","");
      if (oldinstallfailled)
        return LastResult=0;
      if (RegQueryValue(HKEY_CLASSES_ROOT,"scol_file\\shell\\open\\command",MyPath,&msize)!=ERROR_SUCCESS)
      {
        if (RegQueryValue(HKEY_CLASSES_ROOT,"scm_auto_file\\shell\\open\\command",MyPath,&msize)!=ERROR_SUCCESS)
          LastResult=0;
      }
      if (LastResult==0) break;

		    //$LB (20/03/2005) : change usmwin.exe to scol.exe
			// recherche de usmwin.exe
			if ((!strstr(MyPath,"usmwin.exe")) && (!strstr(MyPath,"scol.exe"))) {
				LastResult=0;
				break;
			}

      i=msize-2;
      while (i>=0 && (MyPath[i]!='\\') && (MyPath[i]!='/')) i--;

      if ((i>=0) && (MyPath[i]=='\\' || MyPath[i]=='/')) 
      {
        MyPath[i]=0;
        if (MyPath[0]=='"') 
          path=MyPath+1;
        else 
          path=MyPath;
      }
      setvar("SCOLpath",path);
    }
    break;
  case IGetTempFileName:
    GetTempFileName(DSTDIR,"temp",0,buf);
    setvar(f.srcval,buf);
    break;
  case IAppendFile:
    {
      FILE*file=fopen(f.dest,"a+");
      if (!file) 
        LastResult=0;
      else
      {
        fprintf(file,"%s\n",f.source);
        LastResult=1;
        fclose(file);
      }
    }
    break;
  case IInclude:
    {
      FILE*old=INIFile;
      INIFile=fopen(f.source,"rt");
      if (INIFile)
        ProcessIniFile(hwnddialog,f.dest);
      else
        LastResult=0;
      INIFile=old;
    }
    break;
  case ISetUninstall:
    {
      HKEY hk,hk2;

      RegOpenKey(HKEY_LOCAL_MACHINE,"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall",&hk);
      RegCreateKey(hk,f.source,&hk2);
      RegSetValueEx(hk2,"DisplayName",0,REG_SZ,(const unsigned char*)f.source,strlen(f.source));
      RegSetValueEx(hk2,"UninstallString",0,REG_SZ,(const unsigned char*)f.dest,strlen(f.dest));
	  RegCloseKey(hk2);
	  RegCloseKey(hk);
	  /* modif pour Intel WOF */
      RegCreateKey(HKEY_LOCAL_MACHINE,"SOFTWARE\\Cryo-Networks",&hk);
      RegSetValueEx(hk,"scol_uninstall",0,REG_SZ,(const unsigned char*)f.dest,strlen(f.dest));
	  RegCloseKey(hk);
    }
    break;
  case IDelUninstall:
    {
      HKEY hk;
      RegOpenKeyEx(HKEY_LOCAL_MACHINE,"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall",0,KEY_ALL_ACCESS,&hk);
      RegDeleteKey(hk,f.source);
	  /* modif pour Intel WOF */
      RegOpenKeyEx(HKEY_LOCAL_MACHINE,"SOFTWARE\\Cryo-Networks",0,KEY_ALL_ACCESS,&hk);
      RegDeleteValue(hk,"scol_uninstall");
	  RegCloseKey(hk);
    }
    break;
  case IDelScmAsso:
    {
      HKEY hkey;
      RegDeleteKey(HKEY_CLASSES_ROOT,"scm_auto_file\\shell\\open\\command");
      RegDeleteKey(HKEY_CLASSES_ROOT,"scm_auto_file\\shell\\open");
      RegDeleteKey(HKEY_CLASSES_ROOT,"scm_auto_file\\DefaultIcon");
      RegDeleteKey(HKEY_CLASSES_ROOT,"scm_auto_file\\shell");
      RegDeleteKey(HKEY_CLASSES_ROOT,"scm_auto_file");
      RegDeleteKey(HKEY_CLASSES_ROOT,".scm");
      RegDeleteKey(HKEY_CLASSES_ROOT,"scol_file\\shell\\open\\command");
      RegDeleteKey(HKEY_CLASSES_ROOT,"scol_file\\shell\\open");
      RegDeleteKey(HKEY_CLASSES_ROOT,"scol_file\\DefaultIcon");
      RegDeleteKey(HKEY_CLASSES_ROOT,"scol_file\\shell");
      RegDeleteKey(HKEY_CLASSES_ROOT,"scol_file");
      RegDeleteKey(HKEY_CLASSES_ROOT,".scol");
      if (RegCreateKeyEx(HKEY_LOCAL_MACHINE,"Software\\Cryo-Networks",0,"",REG_OPTION_NON_VOLATILE,KEY_ALL_ACCESS,NULL,&hkey,NULL)==ERROR_SUCCESS)
      {
        RegDeleteValue(hkey,"InstallFailled");
        RegDeleteValue(hkey,"IE");
        RegDeleteValue(hkey,"Netscape");
        RegDeleteValue(hkey,"Success");
        RegCloseKey(hkey);
        RegFlushKey(hkey);
      }
    }
    break;
  case ISetupType:
    LastResult=DialogBox(Instance,"SETUPTYPE",hwnddialog,(DLGPROC)SetupTypeDlgProc);
    if (!LastResult)
    {
			MsgBox(MainHWND,NULL,SETUPNAME,getvar("ABORT_MSG"),NULL);
      EndDialog(hwnddialog,0);
      StopINI=TRUE;
      StopALL=TRUE;
      return TRUE;
    }
    break;
  case IClr:
    clrvar (f.srcval);
    break;

  case IShowWin:
    if (!Silent) ShowWin();
    break;
  case IHideWin:
    if (!Silent) HideWin();
    break;

  case ICD:  
    {
//    GetCurrentDirectory(255,mydir);
//    MessageBox(0,mydir,"Before CD",0);
    _chdir(f.srcval);
//    GetCurrentDirectory(255,mydir);
//    MessageBox(0,mydir,"After CD",0);
    }
    break;
  case IGetScolSettings:
/*    if (!Silent)
      LastResult=DialogBox(Instance,"SCOLSETTINGS",hwnddialog,(DLGPROC)ScolSettingsDlgProc);
    else*/
      LastResult=SetSettings();

/*
LPVOID lpMsgBuf;
FormatMessage( 
    FORMAT_MESSAGE_ALLOCATE_BUFFER | 
    FORMAT_MESSAGE_FROM_SYSTEM | 
    FORMAT_MESSAGE_IGNORE_INSERTS,
    NULL,
    GetLastError(),
    MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
    (LPTSTR) &lpMsgBuf,
    0,
    NULL 
);
// Display the string.
MessageBox( NULL, (LPCTSTR)lpMsgBuf, "Error", MB_OK | MB_ICONINFORMATION );
// Free the buffer.
LocalFree( lpMsgBuf );
*/
    if (!LastResult)
    {
			if (!Silent)
				MsgBox(MainHWND,NULL,SETUPNAME,getvar("ABORT_MSG"),NULL);
      EndDialog(hwnddialog,0);
      oldinstallfailled=1;
      StopINI=TRUE;
      return TRUE;
    }
    break;
  case IGetSMTPServer:
    LastResult=DialogBox(Instance,"SMTP",hwnddialog,(DLGPROC)SMTPDlgProc);
    if (!LastResult)
    {
			MsgBox(MainHWND,NULL,SETUPNAME,getvar("ABORT_MSG"),NULL);
      EndDialog(hwnddialog,0);
      oldinstallfailled=1;
      StopINI=TRUE;
      return TRUE;
    }
    break;
  case IIsScolUpdated:
    {
      char buf[MAX_PATH];
      sprintf(buf,"%s\\%s",DSTDIR,"usm.ini");
      LastResult=IsScolUpdated(buf,f.source);
      return TRUE;
    }
    break;
  case IIsScolRunning:
    {
	  if (IsScolRunning())
		  LastResult=1;
		  else LastResult=0;
      return TRUE;
    }
    break;
  case IImportOldScol:
    ImportOldScol(hwnddialog, f.source,f.dest);
    break;

  case IReplaceFile:
    ReplaceFile(f.source,f.dest);
    break;

  case ICheckForDLL:
    LastResult=CheckForDLL (f.source);
    break;

  case IIsMini:
    LastResult=Mini;
    break;

  case IIsSilent:
    LastResult=Silent;
    break;

  case IIsForced:
    LastResult=Force;
    break;

  case ISetText:
    SetText(hwnddialog,WAITER_TEXT,f.source);
    break;

  case IInstallSuccess:
    InstallSuccess();
    break;

  case IIsEnoughSpace:
    LastResult=IsEnoughSpace(DSTDIR,atoi(getvar("NEEDEDSPACE")));
	break;

  case IGetVersion:
    GetVersion(f.source,f.dest);
    break;

  case IIsGreater:
    LastResult=IsGreater(f.source,f.dest);
    break;

  case IIsLower:
    LastResult=IsGreater(f.dest,f.source);
    break;

  case IMkStr:
		{
		char *buf;
		setvar("QTSTR","");
		buf=(char*)malloc(strlen(f.source)+3);
		if (!buf) break;
		sprintf(buf,"\"%s\"",f.source);
		setvar("QTSTR",buf);
		free(buf);
	    break;
		}
  case ICopyWord : {
		char buf1[MAX_PATH], buf2[MAX_PATH];

		*(int*)buf1=strlen(f.source);
		strcpy(buf1+sizeof(int),f.source);
		buf2[MBcopyword(buf2,(int*)buf1)-buf2]=0;
		setvar("WORD",buf2);
		break;
		}

  case IKillScol : 
	    if (KillScol ())
			LastResult = 1;
		    else LastResult = 0;
		return TRUE;
		break;

  case IIsRebootNeeded : 
		if (iIsRebootNeeded())
			LastResult = 1;
		else 
			LastResult = 0;

		break;

  case IReboot : 
		iRemoveNeedReboot();
	    EndDialog(hwnddialog,0);
		iReboot();
		break;

  case IBKGApplyBackground : 
	  iBkg_applyBackground();
	  iBkg_paint();
	  break;

  case IBKGApplyText : 
	  iBkg_applyText();
	  iBkg_paint();
	  break;

  case IBKGApplyLogo : 
	  iBkg_applyLogo();
	  iBkg_paint();
	  break;

  case IIsUserAuthorized :
	  if (iperms_IsUserAuthorized())
		  LastResult = 1;
	  else LastResult = 0;
	  break;
  case ICreateDSN :
	  sprintf(buf,"DSN=%s;DBQ=%s;DriverId=25;FIL=MS Access",f.source, f.dest );
	  LastResult=SQLConfigDataSource(NULL, ODBC_ADD_SYS_DSN, "Microsoft Access Driver (*.mdb)", buf);
	  break;



  default:
		if (!Silent)
			MsgBox(hwnddialog,NULL,"Install Internal Error","Invalid File Operation");
    oldinstallfailled=1;
    EndDialog(hwnddialog,0);
    break;
  }
//  SendMessage(GetDlgItem(hwnddialog,IDC_FILEPROGRESS),PBM_STEPIT,0,0);
  return 0;
}



int ProcessIniFile (HWND hDlg,char* section)
{
  FileOperation fo;
  char line[1024];
  MSG msg;
  int lastpos;
  int laststop;

  lastpos=ftell(INIFile);
  laststop=StopINI;


  HWND hwnddialog=(HWND)CreateDialog(Instance,"PROGRESSWAITER",hDlg,(DLGPROC)WaiterDlgProc);
  SetText(hwnddialog,WAITER_TEXT,"Setup...");
  if (!Silent)
    TOPShowWindow(hwnddialog,SW_SHOWNORMAL);
  if (Silent)
    ShowWindow(hwnddialog,SW_HIDE);
  PostMessage(GetDlgItem(hwnddialog,IDC_FILEPROGRESS),PBM_SETRANGE,0,MAKELPARAM(0,100));
  PostMessage(GetDlgItem(hwnddialog,IDC_FILEPROGRESS),PBM_SETPOS,0,0);
  PostMessage(GetDlgItem(hwnddialog,IDC_FILEPROGRESS),PBM_SETSTEP,1,0);
  StopINI=FALSE;

  if (INIGetSectionFromStart(section,INIFile))
    while (!INIGetLine(line,1024,INIFile) && !StopINI && !StopALL )
    {
      _log("%s",line);
      char*ptr=passBlank(line);
      if (ptr!=NULL) 
      {
        if (ptr[0]!=';' && ptr[0])
        {
          getCode(&ptr,&fo.code);
          if (fo.code!=-1)
          {
            ptr=passBlank(ptr);
            fo.src=getToken(&ptr,&fo.srcval);
            if (fo.src) fo.source=getvar(fo.srcval);
            else fo.source=fo.srcval;
            ptr=passBlank(ptr);
            fo.dst=getToken(&ptr,&fo.dstval);
            if (fo.dst) fo.dest=getvar(fo.dstval);
            else fo.dest=fo.dstval;


            ProcessFile(hwnddialog,fo);
          }
          else
            Error(getvar("ERROR_INI_SYNTAX"),line);
        }
      }
      _log("... OK\n");
      if (!Silent)
        UpdateWindow(MainHWND);
      for (int truc=0;truc<50;truc++)
      {
        if(PeekMessage(&msg,NULL,0,0,PM_REMOVE))
        {
          TranslateMessage(&msg);
          DispatchMessage(&msg);
        }
      }
    }
  else 
  {
		if (!Silent)
			MsgBox(hwnddialog,NULL,getvar("ERROR_TTL"),getvar("ERROR_INI_INC"));
    if (!oldinstallfailled) 
      DelSemaphore();
    PostQuitMessage (-1);
  }

  fseek(INIFile,lastpos,SEEK_SET);
  StopINI=laststop;

  SendMessage(GetDlgItem(hwnddialog,IDC_FILEPROGRESS),PBM_STEPIT,0,0);
  EndDialog(hwnddialog,0);
  return 0;
}




int IsEnoughSpace(char*DirectoryName,int space)
{
#if 0
  unsigned __int64 FreeBytesAvailableToCaller,TotalNumberOfBytes;
  HINSTANCE l;
  char p[1024];
  unsigned long SectorsPerCluster,BytesPerSector,NumberOfFreeClusters,TotalNumberOfClusters;
  strcpy(p,DirectoryName);

  l=LoadLibrary("Kernel32.dll");
  if (!l) return 0;

  if (GetProcAddress(l,"GetDiskFreeSpaceExA"))
  {
    if (GetDiskFreeSpaceEx(DirectoryName,(PULARGE_INTEGER)&FreeBytesAvailableToCaller,(PULARGE_INTEGER)&TotalNumberOfBytes,NULL)!=ERROR_CALL_NOT_IMPLEMENTED)
    {
      if (space<FreeBytesAvailableToCaller) return 1;
      else return 0;
    }
  }

  p[3]=0;    
  GetDiskFreeSpace(p,&SectorsPerCluster,&BytesPerSector,&NumberOfFreeClusters,&TotalNumberOfClusters);
  FreeBytesAvailableToCaller=SectorsPerCluster*BytesPerSector*NumberOfFreeClusters;
  if (space<FreeBytesAvailableToCaller) return 1;
  else return 0;
#else
  return 1;
#endif
}

/* print the given ressource (a bitmap) inside a control (rectangle) */
BOOL SetPicture( HWND hDlg, int ctrl, int ress )
{
	HWND hwin;
	HDC hwinDC;
	PAINTSTRUCT paint;
	HBITMAP hbmp;
	HDC hbmpDC;

	hwin = GetDlgItem( hDlg, ctrl );
	if (!hwin) {
		_log("erreur GetDlgItem\n");
		return FALSE;
	}

	BeginPaint(hwin, &paint);

	hwinDC = GetDC( hwin );
	if (!hwinDC) {
		_log("erreur GetDC\n");
		return FALSE;
	}

	hbmp = (HBITMAP)LoadImage( Instance, MAKEINTRESOURCE(ress), IMAGE_BITMAP, 0, 0, 0 );
	if (!hbmp) {
		_log("erreur LoadImage\n");
		ReleaseDC( hwin, hwinDC );
		return FALSE;
	}

	hbmpDC = CreateCompatibleDC( hwinDC );
	if (!hbmpDC) {
		_log("erreur CreateCompatibleDC\n");
		ReleaseDC( hwin, hwinDC );
		return FALSE;
	}
	SelectObject( hbmpDC, hbmp );

	if (!BitBlt( hwinDC, 0, 0, 64, 64, hbmpDC, 0, 0, SRCCOPY ))
		_log("erreur BitBlt\n");

	DeleteDC( hbmpDC );
	ReleaseDC( hwin, hwinDC );
	EndPaint(hwin, &paint);

	return TRUE;
}

BOOL CALLBACK DlgProc (HWND hDlg,UINT iMsg,WPARAM wParam,LPARAM lParam)
{
  char buf[MAX_PATH];
  char DirectoryName[MAX_PATH];
  RECT MainRect;
  RECT rect;

  switch (iMsg)
  {
  case WM_INITDIALOG:
	GetWindowRect (MainHWND, &MainRect);
	GetWindowRect (hDlg, &rect);
	SetWindowPos (hDlg, NULL, MainRect.left + ((MainRect.right-MainRect.left)/2) - ((rect.right-rect.left)/2),
		                      MainRect.top + ((MainRect.bottom - MainRect.top)/2) - ((rect.bottom-rect.top)/2),
							  NULL, NULL, SWP_NOZORDER | SWP_NOSIZE);
    SetDlgItemText(hDlg,IDC_STATICINSTALLDIR,getvar("STATICINSTALLDIR"));
    SetDlgItemText(hDlg,IDC_CHANGEDIR,getvar("INTROCHDIR_BTN"));
    SetDlgItemText(hDlg,IDOK,getvar("INTROOK_BTN"));
    SetDlgItemText(hDlg,IDCANCEL,getvar("INTROCANCEL_BTN"));
    SetWindowText(hDlg,getvar("INTRO_TTL"));

    SetDlgItemText(hDlg,TEXT_INTRO,INTRO);
    SetDlgItemText(hDlg,IDC_DESTDIR,DSTDIR);
    SetWindowText(hDlg,APP_TITTLE);
    return TRUE;
  case WM_COMMAND:
    switch (LOWORD(wParam))
    {
    case IDOK:
      GetDlgItemText(hDlg,IDC_DESTDIR,DirectoryName,MAX_PATH);
      
      if (IsEnoughSpace(DirectoryName,atoi(getvar("NEEDEDSPACE")))) EndDialog(hDlg,1);
      else MsgBox(hDlg,NULL,getvar("NOTENOUGHSPACE_TTL"),getvar("NOTENOUGHSPACE_MSG"));
      return TRUE;
    case IDC_CHANGEDIR:
      strcpy(buf,DSTDIR);
      DirTreeDialog(hDlg,buf);
      setvar("DSTDIR",buf);
      SetDlgItemText(hDlg,IDC_DESTDIR,DSTDIR);
      break;
    case IDCANCEL:
      EndDialog(hDlg,0);
      return TRUE;
    }
    break;
  case WM_PAINT:
    SetPicture(hDlg, IDC_LOGO, IDB_LOGO);
	return FALSE;
  }
  return FALSE;
}

BOOL CALLBACK LicenceDlgProc (HWND hDlg,UINT iMsg,WPARAM wParam,LPARAM lParam)
{
  FILE *lic;
  int size;
  char * buf;
  

  switch (iMsg)
  {
  case WM_INITDIALOG:
    lic=fopen(filetoshow,"rb");
    if (!lic) return FALSE;
    fseek(lic,0,SEEK_END);
    size=ftell(lic);
    fseek(lic,0,SEEK_SET);
    buf=(char*)malloc(size);
    if (!buf) return FALSE;
    fread(buf,size,1,lic);
    SetDlgItemText(hDlg,IDC_LICENCE,buf);

    SetText(hDlg,IDOK,getvar("LICENCEOK_BTN"));
    SetText(hDlg,IDCANCEL,getvar("LICENCECANCEL_BTN"));
    SetWindowText(hDlg,getvar("LICENCE_TTL"));
    return TRUE;
  case WM_COMMAND:
    switch (LOWORD(wParam))
    {
    case IDOK:
      EndDialog(hDlg,(LONG)1);
      return TRUE;
    case IDCANCEL:
      EndDialog(hDlg,(LONG)0);
      return TRUE;
    }
    break;
  }
  return FALSE;
}

BOOL CALLBACK WaiterDlgProc (HWND hDlg,UINT iMsg,WPARAM wParam,LPARAM lParam)
{
RECT rect, MainRect;

  switch (iMsg)
  {
  case WM_INITDIALOG:
	GetWindowRect (MainHWND, &MainRect);
	GetWindowRect (hDlg, &rect);
	SetWindowPos (hDlg, NULL, MainRect.left + ((MainRect.right-MainRect.left)/2) - ((rect.right-rect.left)/2),
		                      MainRect.top + ((MainRect.bottom - MainRect.top)/2) - ((rect.bottom-rect.top)/2),
							  NULL, NULL, SWP_NOZORDER | SWP_NOSIZE);
    SetDlgItemText(hDlg,WAITER_TEXT,"Please Wait...");
    return TRUE;
  }
  return FALSE;
}

BOOL CALLBACK FinishDlgProc (HWND hDlg,UINT iMsg,WPARAM wParam,LPARAM lParam)
{
  switch (iMsg)
  {
  case WM_COMMAND:
    switch (LOWORD(wParam))
    {
    case IDOK:
      EndDialog(hDlg,(LONG)TRUE);
      return TRUE;
    }
    default:
      return FALSE;
  }
  return FALSE;
}

#ifdef SERVER
#define KEY2 "11b3e"
#define KEY4 "d243f"
int getIdFromKeycode(char *, char *);
#endif

BOOL CALLBACK SerialNumberDlgProc (HWND hDlg,UINT iMsg,WPARAM wParam,LPARAM lParam)
{

  switch (iMsg)
  {
  case WM_INITDIALOG:
    SetWindowText(hDlg,getvar("SERIALNUMBER_TTL"));
    SetDlgItemText(hDlg,IDC_SN,"");
    SetDlgItemText(hDlg,IDC_STATICTXT,getvar("SERIALNUMBER_TXT"));
    return TRUE;
  case WM_COMMAND:
    switch (LOWORD(wParam))
    {
    case IDOK:
#ifdef SERVER
      char buf[255];
	  int id;
      GetDlgItemText(hDlg,IDC_SN,License,255);
      {
        if (strlen(License)!=20)
        {
          MsgBox(hDlg,NULL,getvar("INVALIDSN_TTL"),getvar("INVALIDSN"));
          return TRUE;
        }
        for (int i=0;(i<20)&&(License[i]=='0');i++) ;
        if (i==20)
        {
          MsgBox(hDlg,NULL,getvar("INVALIDSN_TTL"),getvar("INVALIDSN"));
          return TRUE;
        }
/*
        unsigned short total=0,val;
        char truc[6];
        truc[5]=0;

        for (i=0;i<4;i++) 
        {
          memcpy(truc,buf+i*4,4);
          sscanf(truc,"%x",&val);
          total+=val;
        }
        memcpy(truc,buf+i*4,4);
        sscanf(truc,"%x",&val);

        if (total!=val)
        {
          MsgBox(hDlg,NULL,getvar("INVALIDSN_TTL"),getvar("INVALIDSN"));
          return TRUE;
        }
*/
		sprintf(buf, "%s%s%s%s", KEY1, KEY2, KEY3, KEY4);
		id=getIdFromKeycode(License, buf);
		if ( id<0 )
        {
          MsgBox(hDlg,NULL,getvar("INVALIDSN_TTL"),getvar("INVALIDSN"));
          return TRUE;
        }
      }
#endif
      EndDialog(hDlg,(LONG)1);
      return TRUE;
    case IDCANCEL:
      EndDialog(hDlg,(LONG)0);
      return TRUE;
    }
    break;
  }
  return FALSE;
}

BOOL CALLBACK ForcedIPDlgProc (HWND hDlg,UINT iMsg,WPARAM wParam,LPARAM lParam)
{

  switch (iMsg)
  {
  case WM_INITDIALOG:
    char buf[255];
    SetWindowText(hDlg,getvar("FORCEDIP_TTL"));
	if (gethostname(buf,sizeof(buf)))
		buf[0]=0;
    SetDlgItemText(hDlg,IDC_FORCEDIP,buf);
    SetDlgItemText(hDlg,IDC_IPSTATIC,getvar("FORCEDIP_TXT"));
    return TRUE;
  case WM_COMMAND:
    switch (LOWORD(wParam))
    {
    case IDOK:
      struct hostent *hp;
	  char *ip;
	  ForcedIP[0]=0;
	  DNSname[0]=0;
      GetDlgItemText(hDlg,IDC_FORCEDIP,DNSname,255);
	  if (inet_addr(DNSname)==INADDR_NONE)
		  if (hp=gethostbyname(DNSname))
		  {
			  if (ip=inet_ntoa(*(struct in_addr*)(hp->h_addr)))
				  strcpy(ForcedIP, ip);
			  else
			  {
				MsgBox(hDlg,NULL,getvar("ERROR_TTL"),getvar("ERROR_HOSTNAME"));
				return TRUE;
			  }
		  }
		  else
		  {
			MsgBox(hDlg,NULL,getvar("ERROR_TTL"),getvar("ERROR_HOSTNAME"));
			return TRUE;
		  }
	  else
		  strcpy(ForcedIP, DNSname);
      EndDialog(hDlg,(LONG)1);
      return TRUE;
    }
    break;
  }

  return FALSE;
}

BOOL CALLBACK ScolSettingsDlgProc (HWND hDlg,UINT iMsg,WPARAM wParam,LPARAM lParam)
{
  char buf[255];
  char buf2[255];
  FILE* f;

  switch (iMsg)
  {
  case WM_INITDIALOG:
    SetDlgItemText(hDlg,IDC_nick,"nick");
    SetDlgItemText(hDlg,IDC_email,"");
    SendDlgItemMessage(hDlg,IDC_infocheck,BM_SETCHECK,BST_CHECKED,0);

    SetWindowText(hDlg,getvar("SCOLSETTING_TTL"));
    SetDlgItemText(hDlg,IDC_STATICNICK,getvar("STATICNICK"));
    SetDlgItemText(hDlg,IDC_STATICEMAIL,getvar("STATICEMAIL"));
    SetDlgItemText(hDlg,IDC_infocheck,getvar("STATICINFOCHECK"));
    
    return TRUE;
  case WM_COMMAND:
//  MessageBox(hDlg,"Test","Test",0);
    switch (LOWORD(wParam))
    {
    case IDOK:
      sprintf(buf,"%s\\usmress.ini",DSTDIR);
      f=fopen(buf,"a+t");
      if (!f)
      {
        sprintf(buf2,getvar("ERROR_OPEN_MSG"),buf);
        MsgBox(hDlg,NULL,getvar("ERROR_OPEN_TTL"),buf2);
        EndDialog(hDlg,(LONG)0);
      }

      GetDlgItemText(hDlg,IDC_nick,buf2,255);
      ascii2scol(buf2,buf);
      fprintf(f,"\nDefaultName %s",buf);

      GetDlgItemText(hDlg,IDC_email,buf2,255);
      ascii2scol(buf2,buf);
      fprintf(f,"\nDefaultEmail %s",buf);

      fprintf(f,"\nDefaultLanguage %s",GetLangName(langid));

      if (IsDlgButtonChecked(hDlg,IDC_infocheck)==BST_CHECKED)
        fprintf(f,"\nRegistering Yes");
      else
        fprintf(f,"\nRegistering No");

      fclose(f);
      EndDialog(hDlg,(LONG)1);
      return TRUE;
    case IDCANCEL:
      return TRUE;
    }
    break;
  }
  return FALSE;
}


BOOL CALLBACK SetupTypeDlgProc (HWND hDlg,UINT iMsg,WPARAM wParam,LPARAM lParam)
{
  switch (iMsg)
  {
  case WM_INITDIALOG:
    {
      for (int i=0;i<10;i++)
      {
        char *buf="SETUPTYPE0",*b;
        buf[9]='0'+i;
        b=getvar(buf);

        if (b)
          SendDlgItemMessage(hDlg,IDC_SETUPTYPES,LB_ADDSTRING,0,(long)b);
      }
      SendDlgItemMessage(hDlg,IDC_SETUPTYPES,LB_SETCURSEL,0,0);
      return TRUE;
    }
    break;
  case WM_COMMAND:
    switch (LOWORD(wParam))
    {
    case IDC_SETUPTYPES:
      if (HIWORD(wParam)!=LBN_DBLCLK)
        return TRUE;
    case IDOK:
      {     
        char *buf="SETUPTYPE0",*b;
        buf[9]='0'+(char)SendDlgItemMessage(hDlg,IDC_SETUPTYPES,LB_GETCURSEL,0,0);
        b=getvar(buf);
        setvar("SETUPTYPE",b);
      }
      EndDialog(hDlg,(LONG)1);
      return TRUE;
    case IDCANCEL:
      EndDialog(hDlg,(LONG)0);
      return TRUE;
    }
    break;
  }
  return FALSE;
}

BOOL CALLBACK SMTPDlgProc (HWND hDlg,UINT iMsg,WPARAM wParam,LPARAM lParam)
{
  char server[255];

  switch (iMsg)
  {
  case WM_INITDIALOG:
    SetDlgItemText(hDlg,IDC_SMTP,"mail");
    return TRUE;
  case WM_COMMAND:
    switch (LOWORD(wParam))
    {
    case IDOK:
      GetDlgItemText(hDlg,IDC_SMTP,server,255);
      if (strlen(server))
      {
        setvar("STMPServer",server);
        EndDialog(hDlg,(LONG)1);
      }
      return TRUE;
    }
    break;
  }
  return FALSE;
}