/*

  * Copyright (C) 2014, 2020  J. Ali Harlow <ali@juiblex.co.uk>

  *

  * This program is free software; you can redistribute it and/or modify

  * it under the terms of the GNU General Public License as published by

  * the Free Software Foundation; either version 2 of the License, or

  * (at your option) any later version.

  *

  * This program is distributed in the hope that it will be useful,

  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  * GNU General Public License for more details.

  *

  * You should have received a copy of the GNU General Public License along

  * with this program; if not, write to the Free Software Foundation, Inc.,

  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

  *

  * References:

  *	http://www.transmissionzero.co.uk/computing/win32-apps-with-mingw/

  */

 #include "config.h"

 #ifndef WIN32

 #define _XOPEN_SOURCE 500

 #endif

 #include <stdlib.h>

 #include <stdio.h>

 #include <string.h>

 #include <errno.h>

 #include <lua.h>

 #include <razor.h>

 #include <plover/plover.h>

 #include <plover/uri-handler.h>

 #include <whelk/whelk.h>

 #ifdef WIN32

 #include <windows.h>

 #include <process.h>

 #include <commctrl.h>

 #include "resource.h"

 #ifndef FOF_NO_UI

 #define FOF_NO_UI	(FOF_SILENT|FOF_NOCONFIRMATION|FOF_NOERRORUI|\

 			FOF_NOCONFIRMMKDIR)

 #endif

 #else	/* WIN32 */

 #include <ftw.h>

 #endif	/* WIN32 */

 #include "post.h"

 /*

  * Under WIN32, g_spawn may require a helper program which we'd rather avoid.

  * At least with glib 2.58, this isn't needed if g_spawn_sync() is used (or

  * G_SPAWN_DO_NOT_REAP_CHILD is specified), so we can now define USE_G_SPAWN

  * unconditionally.

  */

 #define USE_G_SPAWN

 LUALIB_API int luaopen_posix(lua_State *L);

 #ifdef WIN32

 DWORD main_thread_id;

 #endif

 gchar *prefix;

 int verify_and_fix(const char *root)

 {

     return 0;

 }

 #ifdef WIN32

 INT_PTR CALLBACK ProgressDialogProc(HWND dialog,UINT msg,WPARAM w_param,

   LPARAM l_param)

 {

     HWND progress;

     DWORD style;

     switch (msg)

     {

 	case WM_INITDIALOG:

 	    progress=GetDlgItem(dialog,IDC_PROGRESS); 

 	    style=GetWindowLong(progress,GWL_STYLE);

 	    SetWindowLong(progress,GWL_STYLE,style|PBS_MARQUEE);

 	    SendMessage(progress,PBM_SETMARQUEE,(WPARAM)TRUE,(LPARAM)30);

 	    return (INT_PTR)TRUE;

     }

     return (INT_PTR)FALSE;

 }

 #endif

 #ifdef WIN32

 __stdcall

 #endif

 unsigned pre_install_thread(void *data)

 {

     gboolean changed;

     int retval;

     const char *repository=data;

     gchar *s,*uri;

     char *install[]={"plover-gtkui",NULL};

     char **pkgs=install;

     struct comps *comps;

     struct comps_group *group;

     struct comps_requirement *pkg;

     struct plover_vector *packages=NULL;

     GError *error=NULL;

     plover__uri_handler_init();

     prefix=plover_pre_install_prefix();

     s=g_strconcat(prefix,"/var/log/pre-install",NULL);

     plover_log_open(s);

     g_free(s);

     s=g_strconcat(prefix,"/var/lib/razor",NULL);

     uri=razor_path_to_uri(s);

     g_free(s);

     razor_set_database_uri(uri);

     free(uri);

     if (verify_and_fix(prefix))

     {

 	g_free(prefix);

 	return -1;

     }

     s=g_strconcat(repository,"/repodata/comps.xml",NULL);

     comps=plover_comps_new_from_uri(s,&error);

     retval=!comps;

     g_free(s);

     if (!retval)

     {

 	group=plover_comps_lookup_group(comps,"installer");

 	if (group)

 	{

 	    packages=plover_vector_new();

 	    do

 	    {

 		changed=FALSE;

 		for(pkg=group->packages;pkg;pkg=pkg->next)

 		{

 		    if (plover_vector_contains(packages,pkg->name))

 			continue;

 		    if (pkg->type==COMPS_REQUIREMENT_DEFAULT ||

 		      pkg->type==COMPS_REQUIREMENT_MANDATORY ||

 		      pkg->type==COMPS_REQUIREMENT_CONDITIONAL &&

 		      plover_vector_contains(packages,pkg->requires))

 		    {

 			changed=TRUE;

 			plover_vector_append(packages,pkg->name);

 		    }

 		}

 	    } while(changed);

 	    pkgs=packages->strings;

 	}

     }

     if (!retval)

 	retval=!plover_install_uri(repository,prefix,pkgs,&error);

     if (!retval)

 	retval=!plover_update_uri(repository,prefix,NULL,&error);

     if (packages)

 	plover_vector_free(packages);

     if (comps)

 	plover_comps_free(comps);

     if (error)

     {

 	fprintf(stderr,"%s\n",error->message);

 	g_error_free(error);

     }

 #ifdef WIN32

     PostQuitMessage(retval);

     PostThreadMessage(main_thread_id,WM_QUIT,retval,0);

     _endthreadex(retval);

 #endif

     return retval;

 }

 /*

  * The idea is that if pre_install() fails, update/setup should fall back

  * to console interfaces.

  */

 #ifdef WIN32

 HANDLE

 #else

 void *

 #endif

 pre_install(const char *repository)

 {

 #ifdef WIN32

     HANDLE retval;

 #else

     void *retval;

 #endif

     razor_set_lua_loader("posix",(void (*)())luaopen_posix);

     razor_set_lua_loader("whelk",(void (*)())luaopen_whelk);

 #ifdef WIN32

     retval=(HANDLE)_beginthreadex(NULL,0,pre_install_thread,(void *)repository,

       0,NULL);

 #else

     if (pre_install_thread((void *)repository))

 	retval=NULL;

     else

 	retval=(void *)1;		/* Non-NULL to indicate success */

 #endif

     return retval;

 }

 #ifndef WIN32

 int remove_ignore(const char *fpath,const struct stat *sb,int typeflag,

   struct FTW *ftwbuf)

 {

     (void)remove(fpath);

     return 0;

 }

 #endif

 gboolean deltree(const char *path)

 {

 #ifdef WIN32

     /* Based on g_local_file_trash() */

     SHFILEOPSTRUCTW op={0};

     gboolean success;

     wchar_t *wfilename;

     long len;

     wfilename=g_utf8_to_utf16(path,-1,NULL,&len,NULL);

     /* SHFILEOPSTRUCT.pFrom is double-zero-terminated */

     wfilename=g_renew(wchar_t,wfilename,len+2);

     wfilename[len+1]=0;

     op.wFunc=FO_DELETE;

     op.pFrom=wfilename;

     op.fFlags=FOF_NO_UI;

     success=!SHFileOperationW(&op);

     if (success && op.fAnyOperationsAborted)

 	success=FALSE;

     g_free(wfilename);

     return success;

 #else

     return nftw(path,remove_ignore,64,FTW_DEPTH|FTW_PHYS);

 #endif

 }

 gboolean pre_uninstall(void)

 {

     gboolean success;

     gchar *s,*uri;

     GError *error=NULL;

     razor_set_lua_loader("posix",(void (*)())luaopen_posix);

     razor_set_lua_loader("whelk",(void (*)())luaopen_whelk);

     prefix=plover_pre_install_prefix();

     s=g_strconcat(prefix,"/var/lib/razor",NULL);

     uri=razor_path_to_uri(s);

     g_free(s);

     razor_set_database_uri(uri);

     free(uri);

     success=plover_remove(NULL,&error);

     if (error)

     {

 	fprintf(stderr,"%s\n",error->message);

 	g_error_free(error);

     }

     deltree(prefix);

     return success;

 }

 #if defined(WIN32) && !defined(USE_G_SPAWN)

 /* Based on glib's g_spawn_win32.c */

 static gchar *

 win32_cmdline_quote(const char *string)

 {

     const gchar *p=string;

     gchar *retval,*q;

     gint len=0;

     gboolean need_dblquotes=FALSE;

     while (*p)

     {

 	if (*p==' ' || *p=='\t')

 	    need_dblquotes=TRUE;

 	else if (*p=='"')

 	    len++;

 	else if (*p=='\\')

 	{

 	    const gchar *pp=p;

 	    while (*pp && *pp=='\\')

 		pp++;

 	    if (*pp=='"')

 		len++;

 	}

 	len++;

 	p++;

     }

     q=retval=g_malloc(len+need_dblquotes*2+1);

     p=string;

     if (need_dblquotes)

 	*q++='"';

     while (*p)

     {

 	if (*p=='"')

 	    *q++='\\';

 	else if (*p=='\\')

 	{

 	    const gchar *pp=p;

 	    while (*pp && *pp=='\\')

 		pp++;

 	    if (*pp=='"')

 		*q++='\\';

 	}

 	*q++=*p;

 	p++;

     }

     if (need_dblquotes)

 	*q++='"';

     *q++='\0';

     return retval;

 }

 /* Create a win32-style wide-character argv with suitable quoting */

 wchar_t **win32_argv_import(char **argv,GError **error)

 {

     int i,n;

     gchar *s;

     wchar_t **wargv;

     GError *tmp_error=NULL;

     n=g_strv_length(argv);

     wargv=g_new(wchar_t *,n+1);

     for(i=0;i<n;i++)

     {

 	s=win32_cmdline_quote(argv[i]);

 	wargv[i]=g_utf8_to_utf16(s,-1,NULL,NULL,&tmp_error);

 	g_free(s);

 	if (!wargv[i])

 	{

 	    g_set_error(error,G_SPAWN_ERROR,G_SPAWN_ERROR_FAILED,

 	      "Invalid argument #%d: %s",i,tmp_error->message);

 	    g_error_free(tmp_error);

 	    for(i--;i>=0;i--)

 		g_free(wargv[i]);

 	    g_free(wargv);

 	    return FALSE;

 	}

     }

     wargv[i]=NULL;

     return wargv;

 }

 gboolean spawn_sync(char **argv,GError **error)

 {

     wchar_t *wargv0,**wargv;

     gintptr rc;

     GError *tmp_error=NULL;

     wargv0=g_utf8_to_utf16(argv[0],-1,NULL,NULL,&tmp_error);

     if (!wargv0)

     {

 	fprintf(stderr,"Conversion error in post\n");

 	g_set_error(error,G_SPAWN_ERROR,G_SPAWN_ERROR_FAILED,

 	  "Invalid program name: %s",tmp_error->message);

 	g_error_free(tmp_error);

 	return FALSE;

     }

     wargv=win32_argv_import(argv,error);

     if (!wargv)

     {

 	fprintf(stderr,"Conversion error in post\n");

 	g_free(wargv0);

 	return FALSE;

     }

     errno=0;

     rc=_wspawnvp(P_WAIT,wargv0,(const wchar_t **)wargv);

     g_free(wargv0);

     g_strfreev((gchar **)wargv);

     if (rc==-1 && errno!=0)

     {

 	fprintf(stderr,"Failed to start post command (%s)\n",g_strerror(errno));

 	g_set_error(error,G_SPAWN_ERROR,G_SPAWN_ERROR_FAILED,

 	  "Failed to execute post command: %s",g_strerror(errno));

 	return FALSE;

     }

     if (rc!=EXIT_SUCCESS)

     {

 	fprintf(stderr,"post command failed (%ld)\n",(long)rc);

 	g_set_error(error,G_SPAWN_ERROR,G_SPAWN_ERROR_FAILED,

 	  "Post command exited with code %ld",(long)rc);

 	return FALSE;

     }

     fprintf(stderr,"post command exited normally\n");

     return TRUE;

 }

 #endif /* defined(WIN32) && !defined(USE_G_SPAWN) */

 gboolean pre_install_spawn_sync(char **argv,GError **error)

 {

     GError *tmp_error=NULL;

 #ifdef USE_G_SPAWN

     gchar *standard_output,*standard_error;

     int exit_status;

     if (!g_spawn_sync(NULL,argv,NULL,G_SPAWN_SEARCH_PATH,NULL,NULL,

       &standard_output,&standard_error,&exit_status,&tmp_error))

     {

 	fprintf(stderr,"Failed to start post command\n");

 	g_propagate_prefixed_error(error,tmp_error,"%s: ",argv[0]);

 	return FALSE;

     }

     if (standard_output && *standard_output)

     {

 	printf("Output from post command %s:\n",argv[0]);

 	fputs(standard_output,stdout);

     }

     g_free(standard_output);

     if (standard_error && *standard_error)

     {

 	printf("Error output from post command %s:\n",argv[0]);

 	fputs(standard_error,stdout);

     }

     g_free(standard_error);

     if (!g_spawn_check_exit_status(exit_status,&tmp_error))

     {

 	fprintf(stderr,"post command failed\n");

 	g_propagate_prefixed_error(error,tmp_error,"%s: ",argv[0]);

 	return FALSE;

     }

 #else

     if (!spawn_sync(argv,&tmp_error))

     {

 	g_propagate_prefixed_error(error,tmp_error,"%s: ",argv[0]);

 	return FALSE;

     }

 #endif

     return TRUE;

 }

 print_arguments(int argc,char **argv)

 {

     int i,j;

     for(i=0;i<argc;i++)

     {

 	if (i)

 	    putchar(' ');

 	if (strchr(argv[i],' ') || strchr(argv[i],'"') || strchr(argv[i],'\n'))

 	{

 	    putchar('"');

 	    for(j=0;argv[i][j];j++)

 	    {

 		if (strchr("$`\"\\\n",argv[i][j]))

 		    putchar('\\');

 		putchar(argv[i][j]);

 	    }

 	    putchar('"');

 	}

 	else

 	    fputs(argv[i],stdout);

     }

 }

 /*

  * Run a command after completing request.

  *

  * Command may refer to %INSTALL_PREFIX% which will be replaced by the

  * (first) install prefix used, by %TEST_RESULT% which will be replaced

  * by either "pass" or "fail" depending as to whether the request succeeded

  * or not and/or by %REPOSITORY% which will be replaced by the URI of the

  * repository used. Command may also include double quotes which will be used

  * to affect how the command is split into arguments much like a shell does.

  */

 gboolean run_post(int argc,char **argv,gboolean test_result,

   const char *repository,GError **error)

 {

     int i,post_argc;

     char *s;

     gchar *expanded;

     gchar **post_argv;

     GError *tmp_error=NULL;

     if (argc<2)

     {

 	g_set_error_literal(error,G_FILE_ERROR,G_FILE_ERROR_NOENT,

 	  "--post: No command given");

 	return FALSE;

     }

     if (!g_shell_parse_argv(argv[1],&post_argc,&post_argv,&tmp_error))

     {

 	g_propagate_prefixed_error(error,tmp_error,"%s: ",argv[1]);

 	return FALSE;

     }

     for(i=0;i<post_argc;i++)

     {

 	s=strstr(post_argv[i],"%INSTALL_PREFIX%");

 	if (s)

 	{

 	    *s='\0';

 	    s+=strlen("%INSTALL_PREFIX%");

 	    expanded=g_strconcat(post_argv[i],prefix,s,NULL);

 	    g_free(post_argv[i]);

 	    post_argv[i]=expanded;

 	}

 	s=strstr(post_argv[i],"%TEST_RESULT%");

 	if (s)

 	{

 	    *s='\0';

 	    s+=strlen("%TEST_RESULT%");

 	    expanded=g_strconcat(post_argv[i],test_result?"pass":"fail",s,NULL);

 	    g_free(post_argv[i]);

 	    post_argv[i]=expanded;

 	}

 	s=strstr(post_argv[i],"%REPOSITORY%");

 	if (s)

 	{

 	    *s='\0';

 	    s+=strlen("%REPOSITORY%");

 	    expanded=g_strconcat(post_argv[i],repository,s,NULL);

 	    g_free(post_argv[i]);

 	    post_argv[i]=expanded;

 	}

     }

     printf("Running post command: ");

     print_arguments(post_argc,post_argv);

     putchar('\n');

     return pre_install_spawn_sync(post_argv,error);

 }

 #ifdef WIN32

 DWORD win32_pre_install_gui(char *repository)

 {

     HANDLE thread;

     INITCOMMONCONTROLSEX icc={0,};

     MSG msg;

     DWORD retval;

     main_thread_id=GetCurrentThreadId();

     thread=(HANDLE)pre_install(repository);

     if (!thread)

 	return EXIT_FAILURE;

     icc.dwSize=sizeof(icc);

     icc.dwICC=ICC_WIN95_CLASSES;

     InitCommonControlsEx(&icc);

     DialogBox(GetModuleHandle(NULL),MAKEINTRESOURCE(IDD_PROGRESSDIALOG),NULL,

       &ProgressDialogProc);

     while(GetMessage(&msg,NULL,0,0)>0)

     {

 	TranslateMessage(&msg);

 	DispatchMessage(&msg);

     }

     WaitForSingleObject(thread,INFINITE);

     GetExitCodeThread(thread,&retval);

     CloseHandle(thread);

     return retval;

 }

 #endif	/* WIN32 */

 gchar *pre_install_default_repository(const char *argv0)

 {

     size_t length;

     void *contents;

     gchar *path;

     gchar *s,*uri;

     struct razor_error *tmp_error=NULL;

     /*

      * The default repository is the executable itself if it's an archive

      * or otherwise the directory in which the executable is stored.

      */

     path=plover_get_program(argv0);

     uri=razor_path_to_uri(path);

     free(path);

     s=g_strconcat(uri,"/repodata/comps.xml",NULL);

     contents=razor_uri_get_contents(s,&length,FALSE,&tmp_error);

     g_free(s);

     if (contents)

 	razor_uri_free_contents(contents,length);

     else

     {

 	if (razor_error_matches(tmp_error,RAZOR_GENERAL_ERROR,

 	  RAZOR_GENERAL_ERROR_UNSUPPORTED_ARCHIVE))

 	{

 	    path=plover_get_program_directory(argv0);

 	    uri=razor_path_to_uri(path);

 	    free(path);

 	}

 	razor_error_free(tmp_error);

     }

     return uri;

 }

 gboolean pre_install_post(int argc,char **argv,gboolean success,

   const char *repository)

 {

     gchar *s,*uri;

     struct post *post=NULL;

     GError *error=NULL;

     if (!argv && !success)

     {

 	/*

 	 * If no --post command has been given, then we want to run the

 	 * program specified in %INSTALL_PREFIX%/etc/pre-inst.post

 	 * However, if the pre-install failed, then that file isn't likely

 	 * to exist (and it's requirements even less so) so we issue an error

 	 * instead. Unfortunately, it's hard to include the error message

 	 * here. It will have been logged in the plover log, but that's not

 	 * much help to users.

 	 */

 #ifndef WIN32

 	fprintf(stderr,

 	  "Installation failed: Failed to unpack the main installer\n");

 #else

 	MessageBox(NULL,"Failed to unpack the main installer",

 	  "Installation failed",MB_ICONERROR|MB_OK);

 #endif

 	return FALSE;

     }

     if (!argv)

     {

 	post=pre_install_post_new(repository,prefix);

 	uri=razor_path_to_uri(prefix);

 	s=g_strconcat(uri,"/etc/pre-inst.post",NULL);

 	g_free(uri);

 	pre_install_post_load_uri(post,s,&error);

 	if (error)

 	    g_debug("Failed to load post configuration from pre-inst.post: %s",

 	      error->message);

 	g_free(s);

 	if (g_error_matches(error,PLOVER_POSIX_ERROR,ENOENT))

 	{

 	    /*

 	     * If no post configuration file exists, that's not an error;

 	     * there simply is no post action configured.

 	     */

 	    g_clear_error(&error);

 	}

     }

     if (post && post->argc>0)

     {

 	printf("Running post command: ");

 	print_arguments(post->argc,post->argv);

 	putchar('\n');

 	pre_install_spawn_sync(post->argv,&error);

     }

     else if (argv)

 	run_post(argc,argv,success,repository,&error);

     if (post)

 	pre_install_post_free(post);

     if (error)

     {

 #ifndef WIN32

 	fprintf(stderr,"Error in post: %s\n",error->message);

 #else

 	MessageBox(NULL,error->message,"Error in post",MB_ICONERROR|MB_OK);

 #endif

 	g_error_free(error);

 	success=FALSE;

     }

     return success;

 }

 int main(int argc,char **argv)

 {

     gboolean success,uninstall=FALSE,enable_post=FALSE;

     GError *error=NULL;

     gchar *path=NULL,*repository=NULL;

     GOptionContext *context;

     GOptionEntry options[]={

 	{"repository",0,0,G_OPTION_ARG_STRING,&repository,

 	  "Repository location","uri"},

 	{"path",0,0,G_OPTION_ARG_FILENAME,&path,

 	  "Repository path","path"},

 	{"uninstall",'u',0,G_OPTION_ARG_NONE,&uninstall,

 	  "Uninstall all packages",NULL},

 	{"post",0,0,G_OPTION_ARG_NONE,&enable_post,

 	  "Run command after request is processed",NULL},

 	{NULL}

     };

 #ifdef WIN32

     /*

      * pre-inst is normally a GUI application, but rpm scripts may well

      * call console applications and it looks ugly if console windows keep

      * popping up. Avoid this by allocating our own console and hiding it.

      * Note:

      *	- If pre-inst is a console application (typically for debugging),

      *    then skip this step.

      *  - Call ShowWindow twice to negate special handling on first call.

      */

     if (!GetConsoleWindow())

     {

 	AllocConsole();

 	ShowWindow(GetConsoleWindow(),SW_HIDE);

 	ShowWindow(GetConsoleWindow(),SW_HIDE);

     }

 #endif

     plover_exception_handler_init();

     context=g_option_context_new("[command] - install the main installer");

     g_option_context_add_main_entries(context,options,NULL);

     g_option_context_set_description(context,

       "If --post is specified, then the command to run and its arguments\n"

       "should be listed at the end of the command line.\n"

       "Command may refer to %INSTALL_PREFIX% which will be replaced by the\n"

       "(first) install prefix used, by %TEST_RESULT% which will be\n"

       "replaced by either \"pass\" or \"fail\" depending as to whether the\n"

       "request succeeded or not and/or by %REPOSITORY% which will be\n"

       "replaced by the URI of the repository used. Command may also include\n"

       "double quotes which will be used to affect how the command is split\n"

       "into arguments much like a shell does.");

     g_option_context_set_strict_posix(context,TRUE);

     g_option_context_set_ignore_unknown_options(context,TRUE);

     if (!g_option_context_parse(context,&argc,&argv,&error))

     {

 	g_printerr("pre-install: %s\n",error->message);

 	g_printerr("Use \"%s --help\" for help\n",argv[0]);

 	exit(1);

     }

     if (repository && path)

     {

 	g_printerr("pre-install: "

 	  "Only one of --repository and --path can be specified\n");

 	exit(1);

     }

     if (path)

 	repository=razor_path_to_uri(path);

     else if (!repository)

 	repository=pre_install_default_repository(argv[0]);

     if (uninstall)

 	success=pre_uninstall();

     else

     {

 #ifdef WIN32

 	success=win32_pre_install_gui(repository)==EXIT_SUCCESS;

 #else

 	success=!!pre_install(repository);

 #endif

     }

     if (enable_post)

 	success=pre_install_post(argc,argv,success,repository);

     else if (!uninstall)

 	success=pre_install_post(0,NULL,success,repository);

 #ifdef WIN32

     return success?EXIT_SUCCESS:EXIT_FAILURE;

 #else

     return success?0:1;

 #endif

 }