init.c

-一个LINUX下的使用方&#63845 的CD-ROM刻录软件,开放源码

/* 
	init.c
	15.3.99 tn
*/

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <string.h>
#include <strings.h>
#if defined(linux) || defined(__CYGWIN32__)
#include <getopt.h>
#endif
#include <gtk/gtk.h>
#include <gdk/gdk.h>
#include <gdk_imlib.h>
#include "xcdroast.h"
#include "main.h"

extern setup_data_t setupdata;
extern current_set_t curset;
extern cd_info_t cdinfo;
extern track_info_t **trackinfo;
extern gint language;
extern track_read_set_t trackreadset;
extern GList *imagelist;
extern GList *writelist;
extern write_track_param_t writeparams;
extern gint wav_in;
extern GList *tocfiles;
extern gint debug;
extern gchar xcdroast_version_loaded[MAXLINE];
extern master_param_t masterparam;
extern gint oldfontcode;
extern gint ignorescanbus;
extern writer_driver_t **drv_options;
extern gint drvoptcount;

gchar *system_platform;
gchar hostname[MAXLINE];
gchar username[MAXLINE];
gchar configdir[MAXLINE];
gchar sharedir[MAXLINE];


/* give the setupdata-structure valid startvalues */

void init_setupdata() {
gchar tmp[MAXLINE];

	setupdata.writer_devnr = -1;
	strcpy(setupdata.writer_vendor,"");
	strcpy(setupdata.writer_model,"");
	setupdata.writer_mode = -1;
	setupdata.writer_speed = 1;
	setupdata.writer_fifo = 4096;

	setupdata.readdev1_devnr = -1;
	strcpy(setupdata.readdev1_vendor,"");
	strcpy(setupdata.readdev1_model,"");
	setupdata.readdev2_devnr = -1;
	strcpy(setupdata.readdev2_vendor,"");
	strcpy(setupdata.readdev2_model,"");
	setupdata.audioread_interface = 0;
	setupdata.audioread_speed = 1;
	setupdata.audioread_overlap = 0;
	setupdata.audioread_sectorburst = 75;

	setupdata.image_dirs = NULL;
	
	setupdata.dsp_device = g_strdup("");
	setupdata.mix_device = g_strdup("");
	setupdata.notify_via = 1;
	setupdata.notify_at = 0;

	setupdata.cddb_host = g_strdup("freedb.freedb.org");
	setupdata.cddb_port = 888;

	g_snprintf(tmp,MAXLINE,"%s/%s", CONFIGDIR, LOGFILE);
	setupdata.logfile = g_strdup(tmp);
	setupdata.loglevel = 0;

	setupdata.language = -1;	

	setupdata.option_tooltips = 1;
	setupdata.option_autoraise = 0;
	setupdata.option_savepos = 0;
	setupdata.option_personimage = 0;
	setupdata.option_overwritewarn = 0;
	setupdata.option_autodelete = 0;
	setupdata.option_titleprogress = 0;
	setupdata.option_displaycdtext = 1;
	setupdata.option_selectionmode = 0;
}


/* init current-set-structure */

void init_curset() {

	curset.writer_devnr = -1;
	curset.reader_devnr = -1;
	curset.writer_speed = -1;
	curset.audioread_speed = -1;
	curset.image_index = -1;
	curset.proc_view = 1;
	curset.file_prefix = g_strdup("");
	curset.tocfile = g_strdup("");
	curset.cdrtype = 0;
	curset.writemode = 0;
	curset.writesimul = 0;
	curset.writeeject = 1;
	curset.writepad = 1;
	curset.writeswap = 0;
	curset.nofixate = 0;
	curset.multisession = 0;
	curset.blankmode = 0;
	curset.blank_force = 0;
	curset.blank_eject = 1;
	curset.noaudioverify = 0;
	curset.verifyfailabort = 0;
	curset.indexscan = 1;
}


/* init cdinfo and trackinfo-structure */

void init_cdinfo() {

	cdinfo.nr_tracks = 0;
	cdinfo.total_size = 0;
	strcpy(cdinfo.cddb_discid,"00000000");
	cdinfo.have_cdtext = 0;
	cdinfo.have_cdextra = 0;
	cdinfo.title = NULL;
	cdinfo.artist = NULL;
	cdinfo.cddb_dtitle = NULL;
	cdinfo.leadout = 0;	

	/* allocate tracks */
	trackinfo = g_new0(track_info_t *,MAXTRACKS);
}


/* init trackreadset-variable */

void init_trackreadset() {

	trackreadset.nrtracks = 0;
	trackreadset.tocfile = g_strdup("");
	trackreadset.cdtitle = g_strdup("");
	trackreadset.trackparams = NULL;
}


/* init writeparams-structure */

void init_writeparams() {

	writeparams.nrtracks = 0;
	writeparams.simulation = 0;
	writeparams.tracktype = NULL;
	writeparams.frames = NULL;
	writeparams.pct_so_far_arr = NULL;
	writeparams.pct_this_track_arr = NULL;
}


/* init master-parameters */

void init_masterparams() {
int i;

	masterparam.mstr_redir = NULL;
	masterparam.exclude_paths = NULL;
	masterparam.show_only_dirs = 1;
	masterparam.image_type = -1;
	for (i=0; i<16; i++) 
		masterparam.opt[i] = 0;	
	masterparam.bootable = 0;
	masterparam.boot_image = g_strdup("");
	masterparam.boot_catalog = g_strdup(DEF_BOOT_CATALOG);
	masterparam.boot_type = 0;
	masterparam.sparc_boot = g_strdup("");
	masterparam.volid = g_strdup("");
	masterparam.publisher = g_strdup("");
	masterparam.preparer = g_strdup("");
	masterparam.application = g_strdup("");
	masterparam.abstract = g_strdup("");
	masterparam.biblio = g_strdup("");
	masterparam.copyright = g_strdup("");
	masterparam.image_filename = g_strdup("");
	masterparam.old_session_size = 0;
	masterparam.session_size = 0;
}

void init_drv_options() {

	drv_options=NULL;
	drvoptcount = 0;
}


/* stat a file and see if its a binary */

gint check_executable(gchar *file, gint share) {
struct stat buf;
gchar tmp[MAXLINE];
gchar tmp2[MAXLINE];
gchar *p;

	/* strip first all after a space in filename (arguments) */
	strcpy(tmp,file);
	p = strtok(tmp," ");
	if (p != NULL) {
		strcpy(tmp2,p);
		strcpy(tmp,tmp2);
	}

	if (stat(tmp,&buf) != 0) {
		g_warning("No %s installed\n", file);
		if (share) 
			g_warning("(Invalid lib-directory? Check -l option)\n");
		gtk_exit(1);
	}
	if (!(buf.st_mode & S_IEXEC)) {
		g_warning("%s not executable\n", file);
		gtk_exit(1);
	}

	return 0;
}


/* check if needed binaries are installed */

void check_binaries() {
gchar tmp[MAXLINE];
gchar ver[MAXLINE];
	
	check_executable(UNAME,0);
	check_executable(DF,0);

	get_spawn_path(CDRECORD,tmp);
	check_executable(tmp,1);
	get_spawn_path(CDDA2WAV,tmp);
	check_executable(tmp,1);
	get_spawn_path(READCD,tmp);
	check_executable(tmp,1);
	get_spawn_path(MKISOFS,tmp);
	check_executable(tmp,1);

	g_snprintf(tmp,MAXLINE,"%s/%s", sharedir, WAVPLAY);
	check_executable(tmp,1);
	g_snprintf(tmp,MAXLINE,"%s/%s", sharedir, RMTOOL);
	check_executable(tmp,1);
	g_snprintf(tmp,MAXLINE,"%s/%s", sharedir, VRFYTOOL);
	check_executable(tmp,1);
	g_snprintf(tmp,MAXLINE,"%s/%s", sharedir, CDDBTOOL);
	check_executable(tmp,1);

	/* now check the versions of the binaries */
	if (check_version_cdrecord(CDRECORD_VERSION,ver)) {
		g_warning("Invalid cdrecord version %s found. Expecting version %s\n", ver, CDRECORD_VERSION);	
		gtk_exit(1);
	}
	if (check_version_mkisofs(MKISOFS_VERSION,ver)) {
		g_warning("Invalid mkisofs version %s found. Expecting version %s\n", ver, MKISOFS_VERSION);	
		gtk_exit(1);
	}
	if (check_version_cdda2wav(CDDA2WAV_VERSION,ver)) {
		g_warning("Invalid cdda2wav version %s found. Expecting version %s\n", ver, CDDA2WAV_VERSION);	
		gtk_exit(1);
	}
	if (check_version_readcd(READCD_VERSION,ver)) {
		g_warning("Invalid readcd version %s found. Expecting version %s\n", ver, READCD_VERSION);	
		gtk_exit(1);
	}
}


/* check if we have enough rights to execute xcdroast */

void check_root() {

#if !defined(__CYGWIN32__)
	if (getuid() != 0) {
		g_warning("Require root-rights to execute this alpha-version of X-CD-Roast.\n\t\tNote: Running with suid-bit root won't work.\n\t\t(The final version of X-CD-Roast will NOT need root-permissions)\n");
		gtk_exit(1);
	}
#endif

}


/* check if we have at least 800x600 virtual screen size */
/* for bigfonts we need 1024x768 */

gint check_screensize(gint bigfonts) {
gint xsize, ysize;

	xsize = gdk_screen_width();
	ysize = gdk_screen_height();

	if (bigfonts == 0) {
		if (xsize < 800 || ysize < 600) 
			return 1;
	} else {
		if (xsize < 1024 || ysize < 768) 
			return 1;
	}
	return 0;
}


/* print usage-info */

void usage(gchar *cmd) {

	g_print("Usage: %s [options]  (Version: %s)\n", cmd, XCDROAST_VERSION);
	g_print("Options:\n");
	g_print("\t-d <debug level>\n");
	g_print("\t-c <config directory> (currently: %s)\n", configdir);
	g_print("\t-l <lib directory>  (currently: %s)\n", sharedir);
	g_print("\t-o : Disable multibyte font support\n");
	g_print("\t-i : Ignore SCSI-scan (allows you to start xcdroast without\n\t     any scsi-support)\n");
	
	g_print("Some GTK-Options:\n");
	g_print("\t--display <remote host>\n");
	g_print("\t--sync\n");
	g_print("\t--no-xshm\n");
}


/* Misc-init-stuff. stuff done once at program-startup */
/* return 0 if config file ok loaded, 1 on failure */

gint init(gint argc, gchar *argv[]) { 
gchar tmp[MAXLINE];
gchar *p1;
gint c;
	
	language = -1;
	debug = 0;
	oldfontcode = 0;
	ignorescanbus = 0;
	strncpy(configdir, CONFIGDIR, MAXLINE);

#ifdef PRE_LIBDIR 
	/* use prefix as sharedir as it came from the makefile-option */
	strncpy(sharedir, PRE_LIBDIR, MAXLINE);
#else
	/* otherwise install our default prefix */
	strncpy(sharedir, LIBDIR, MAXLINE);
#endif

	/* parse command-line */
	while ((c = getopt(argc,argv,"d:c:l:oi")) != EOF)
	switch ((gchar)c) {
	
	case 'd':
		debug = atoi(optarg);
		break;

	case 'c':
		strncpy(configdir, optarg, MAXLINE);
		break;

	case 'l':
		strncpy(sharedir, optarg, MAXLINE);
		break;

	case 'o':
		oldfontcode = 1;
		break;

	case 'i':
		ignorescanbus = 1;
		break;

	default:
		usage(argv[0]);
		gtk_exit(1);
	}


	/* get some system-info */
	system_platform = g_strdup(strip_string(get_uname_info(tmp)));
	if (gethostname(hostname,MAXLINE) != 0) {
		strncpy(hostname,"not_available",MAXLINE);
	}
	p1 = g_get_user_name();
	if (p1 != NULL) {
		strncpy(username,p1, MAXLINE);
	} else {
		strncpy(username,"not_available",MAXLINE);
	}

	/* subst ~/ by $HOME */
	check_tilde(configdir);

	dodebug(1, "Starting X-CD-Roast %s by %s@%s on %s\n", 
		XCDROAST_VERSION,  username, hostname, system_platform);
	dodebug(1, "debug level: %d\n", debug);
	dodebug(1, "configdir: %s\n", configdir);
	dodebug(1, "libdir: %s\n",sharedir);

	dodebug(3, "Checking for helper binaries\n");
	check_binaries();

	/* check for permissions */
	check_root();

	/* load language files */
	g_snprintf(tmp,MAXLINE,"%s/lang/language.def", sharedir);
	load_langfile(tmp);
	g_snprintf(tmp,MAXLINE,"%s/lang/langhelp.def", sharedir);
	load_helpfile(tmp);

	/* look for enviroment-variable $LANG - if not found set language
	   to english */
	scan_lang();

	scanbus();
	scandrivers();
	scanblankmodes();

	dodebug(3, "Initializing global data structures\n");
	wav_in = -1;
	init_setupdata();
	init_curset();
	init_cdinfo();
	init_trackreadset();
	init_writeparams();
	init_masterparams();
	init_drv_options();
	imagelist = (GList *) NULL;
	writelist = (GList *) NULL;
	tocfiles = (GList *) NULL;
	strcpy(xcdroast_version_loaded, "");

	dolog(1, "Starting X-CD-Roast %s by %s@%s on %s\n", 
		XCDROAST_VERSION,  username, hostname, system_platform);

	/* load iso-options if available */
	g_snprintf(tmp,MAXLINE,"%s/%s", configdir, ISOOPTFILE);
	load_isooptions_file(tmp);

	/* load iso-headers if available */
	g_snprintf(tmp,MAXLINE,"%s/%s", configdir, ISOHEADERFILE);
	load_isoheaders_file(tmp);

	/* load config file - if possible */
	g_snprintf(tmp,MAXLINE,"%s/%s", configdir, CONFFILE);
	if (load_setup_config(tmp) == 0) {
		/* load ok */

	        if (setupdata.language >= 0) {
       		        language = setupdata.language;
        	} else {
                	/* get language from locale */
               		scan_lang();
        	}

		return 0;
	} else {
		/* load failed */
		return 1;
	}
}