[people/teissler/ipfire-2.x.git] / src / install+setup / libsmooth / main.c

/* SmoothWall libsmooth.
 *
 * This program is distributed under the terms of the GNU General Public
 * Licence.  See the file COPYING for details.
 *
 * (c) Lawrence Manning, 2001
 * Contains library functions.
 * 
 * $Id: main.c,v 1.6.2.9 2005/12/09 22:31:41 franck78 Exp $
 * 
 */
 
#include "libsmooth.h"

extern FILE *flog;
extern char *mylog;

extern char **ctr;
  
/* reboot().  reboots. */
void reboot(void)
{
	mysystem("/etc/halt");
}

/* stripnl().  Replaces \n with \0 */
void stripnl(char *s)
{
	char *t = strchr(s, '\n');
	if (t) *t = '\0';
}

/* Little wrapper. */
int mysystem(char *command)
{
	char mycommand[STRING_SIZE];
	
	snprintf(mycommand, STRING_SIZE, "%s >>%s 2>>%s", command, mylog, mylog);
	fprintf(flog, "Running command: %s\n", command);
	return system(mycommand);
}

void errorbox(char *message)
{
	newtWinMessage(ctr[TR_ERROR], ctr[TR_OK], message);
}

int scrollmsgbox(int width, int height, char *title, char *text, ...)
{
	int rc = 0;
	newtComponent t, f, b, c;
	char *buf = NULL;
	char checkbox;
	int size = 0;
	int i = 0;
	va_list args;

	va_start(args, text);

	do {
		size += 40000;
		if (buf) free(buf);
		buf = malloc(size);
		i = vsnprintf(buf, size, text, args);
	} while (i == size);

	va_end(args);

	newtCenteredWindow(width, height, title);

	b = newtCompactButton(width - 15 ,height - 2, ctr[TR_OK]);
	c = newtCheckbox(3, height - 2, ctr[TR_LICENSE_ACCEPT], ' ', " *", &checkbox);

	t = newtTextbox(1, 1, width - 2, height - 4, NEWT_TEXTBOX_WRAP+NEWT_TEXTBOX_SCROLL);
	newtTextboxSetText(t, buf);

	f = newtForm(NULL, NULL, 0);
	free(buf);

	newtFormAddComponent(f, c);
	newtFormAddComponent(f, b);
	newtFormAddComponent(f, t);

	newtRunForm(f);
	if (checkbox=='*') rc=1;
	newtFormDestroy(f);
	return rc;
}

int disclaimerbox(char *message)
{
	int rc;
	char title[STRING_SIZE];
	
	sprintf (title, "%s v%s - %s", NAME, VERSION, SLOGAN);
	rc = scrollmsgbox(75, 20, title, message);
	newtPopWindow();
	
	return rc;
}


void statuswindow(int width, int height, char *title, char *text, ...)
{
	newtComponent t, f;
	char *buf = NULL;
	int size = 0;
	int i = 0;
	va_list args;

	va_start(args, text);

	do {
		size += 1000;
		if (buf) free(buf);
		buf = malloc(size);
		i = vsnprintf(buf, size, text, args);
	} while (i == size);

	va_end(args);

	newtCenteredWindow(width, height, title);

	t = newtTextbox(1, 1, width - 2, height - 2, NEWT_TEXTBOX_WRAP);
	newtTextboxSetText(t, buf);
	f = newtForm(NULL, NULL, 0);

	free(buf);

	newtFormAddComponent(f, t);

	newtDrawForm(f);
	newtRefresh();
	newtFormDestroy(f);
}

int runcommandwithstatus(char *command, char *message)
{
	int rc;
	char title[STRING_SIZE];
	
	sprintf (title, "%s v%s - %s", NAME, VERSION, SLOGAN);
	statuswindow(60, 4, title, message);
	rc = mysystem(command);
	newtPopWindow();
	
	return rc;
}

int runhiddencommandwithstatus(char *command, char *message)
{
	int rc;
	char title[STRING_SIZE];
	char mycommand[STRING_SIZE];
	
	sprintf (title, "%s v%s - %s", NAME, VERSION, SLOGAN);
	statuswindow(60, 4, title, message);
	snprintf(mycommand, STRING_SIZE, "%s >>%s 2>>%s", command, mylog, mylog);
	fprintf(flog, "Running command: ***** HIDDEN *****\n");
	rc = system(mycommand);
	newtPopWindow();
	
	return rc;
}

/* This one borrowed from redhat installer. */
int runcommandwithprogress(int width, int height, char *title, char *command,
	int lines, char *text, ...)
{
	newtComponent t, f, s;
	char *buf = NULL;
	int size = 0;
	int i = 0;
	va_list args;
	int rc = 0;
	FILE *p;
	char buffer[STRING_SIZE];
	int progress = 0;
	char mycommand[STRING_SIZE];

	va_start(args, text);

	do {
		size += 1000;
		if (buf) free(buf);
		buf = malloc(size);
		i = vsnprintf(buf, size, text, args);
	} while (i == size);

	va_end(args);

	newtCenteredWindow(width, height, title);

	t = newtTextbox(1, 1, width - 2, height - 2, NEWT_TEXTBOX_WRAP);
	newtTextboxSetText(t, buf);
	f = newtForm(NULL, NULL, 0);

	free(buf);

	newtFormAddComponent(f, t);
	
	s = newtScale(1, 3, width - 2, lines);
	newtScaleSet(s, progress);
	
	newtFormAddComponent(f, s);

	newtDrawForm(f);
	newtRefresh();
	
	snprintf(mycommand, STRING_SIZE, "%s 2>>%s", command, mylog);
	fprintf(flog, "Running command: %s\n", command);
	
	if (!(p = popen(command, "r")))
	{
		rc = 1;
		goto EXIT;
	}
	setvbuf(p, NULL, _IOLBF, 255);
	
	while (fgets(buffer, STRING_SIZE, p))
	{
		newtScaleSet(s, ++progress);
		newtRefresh();	
		fprintf(flog, "%s", buffer);
	}
		
	rc = pclose(p);
	
EXIT:
	newtFormDestroy(f);
	newtPopWindow();
		
	return rc;
}

int checkformodule(char *module)
{
	FILE *file;
	char buffer[STRING_SIZE];
	int result = 0;
	
	if (!(file = fopen("/proc/modules", "r")))
	{
		fprintf(flog, "Unable to open /proc/modules in checkformodule()\n");
		return 0;
	}
	
	while (fgets(buffer, STRING_SIZE, file))
	{
		if (strncmp(buffer, module, strlen(module)) == 0)
		{
			if (buffer[strlen(module)] == ' ')
			{
				result = 1;
				goto EXIT;
			}
		}
	}
	
EXIT:
	fclose(file);
	
	return result;
}	
		
int _replace_string(char string[], char *from, char *to)
{
	int fromlen = strlen(from);
	int tolen = strlen(to);
	char *start, *p1, *p2;
	for(start = string; *start != '\0'; start++)
	{
		p1 = from;
		p2 = start;
		while(*p1 != '\0')
		{
			if(*p1 != *p2)
				break;
			p1++;
			p2++;
		}
		if(*p1 == '\0')
		{
			if(fromlen != tolen)
			{
				memmove(start + tolen, start + fromlen,
					strlen(start + fromlen) + 1);
			}
			for(p1 = to; *p1 != '\0'; p1++)
				*start++ = *p1;
			return 1;
		}
	}
	return 0;
}

int replace(char filename1[], char *from, char *to)
{
	FILE *file1, *file2;
	char filename2[1000];
	char temp[1000];
	int ret = 0;

	/* Open the source and destination files */
	strcpy (filename2, filename1);
	strcat (filename2, ".new");
	if (!(file1 = fopen (filename1, "r"))) return 1;
	if (!(file2 = fopen (filename2, "w"))) {
		fclose(file1);
		return -1;
	}

	/* Start reading in lines */
	while (fgets (temp, 1000, file1) != NULL) {

		if (strlen(to) > 0) {
			/* Replace string */
			ret = _replace_string (temp, from, to);
		
			/* Write string to new file */
			fputs(temp, file2);
		} else {
			/* Remove string when to is NULL */
			if (!strstr(temp, from)) 
				fputs(temp, file2);
		}
	}

	/* Close source and destination */
	fclose (file1);
	fclose (file2);

	/* Move the file */
	rename (filename2, filename1);
	
	return (ret);
}

/* Include enabled languages */
#ifdef  LANG_EN_ONLY
        #include "lang_en.c"
#else
	#include "lang_de.c"
	#include "lang_en.c"
	#include "lang_es.c"
	#include "lang_fr.c"
	#include "lang_pl.c"
	#include "lang_ru.c"
#endif

// returns a pointer to the actual running version number of IPFire.
// Successive updates increase effective version but not VERSION !
char g_title[STRING_SIZE] = "";
char* get_version(void) {
	FILE *f_title;
	if ((f_title = fopen ("/etc/issue", "r"))) {
		fgets (g_title, STRING_SIZE, f_title);
		fclose (f_title);
		if (g_title[strlen(g_title) - 1] == '\n') g_title[strlen(g_title) - 1] = '\0';
	} else {
	        sprintf (g_title, "%s %s - %s", NAME, VERSION, SLOGAN);
	}
	return g_title;
}
Commit	Line	Data
3d6e1202 MT	1	/* SmoothWall libsmooth.
	2	*
	3	* This program is distributed under the terms of the GNU General Public
	4	* Licence. See the file COPYING for details.
	5	*
	6	* (c) Lawrence Manning, 2001
	7	* Contains library functions.
	8	*
	9	* $Id: main.c,v 1.6.2.9 2005/12/09 22:31:41 franck78 Exp $
	10	*
	11	*/
	12
	13	#include "libsmooth.h"
	14
	15	extern FILE *flog;
	16	extern char *mylog;
	17
	18	extern char **ctr;
	19
	20	/* reboot(). reboots. */
	21	void reboot(void)
	22	{
	23	mysystem("/etc/halt");
	24	}
	25
	26	/* stripnl(). Replaces \n with \0 */
	27	void stripnl(char *s)
	28	{
	29	char *t = strchr(s, '\n');
	30	if (t) *t = '\0';
	31	}
	32
	33	/* Little wrapper. */
	34	int mysystem(char *command)
	35	{
	36	char mycommand[STRING_SIZE];
	37
	38	snprintf(mycommand, STRING_SIZE, "%s >>%s 2>>%s", command, mylog, mylog);
	39	fprintf(flog, "Running command: %s\n", command);
	40	return system(mycommand);
	41	}
	42
	43	void errorbox(char *message)
	44	{
	45	newtWinMessage(ctr[TR_ERROR], ctr[TR_OK], message);
	46	}
	47
e0bbaf87 AF	48	int scrollmsgbox(int width, int height, char title, char text, ...)
	49	{
	50	int rc = 0;
	51	newtComponent t, f, b, c;
	52	char *buf = NULL;
	53	char checkbox;
	54	int size = 0;
	55	int i = 0;
	56	va_list args;
	57
	58	va_start(args, text);
	59
	60	do {
	61	size += 40000;
	62	if (buf) free(buf);
	63	buf = malloc(size);
	64	i = vsnprintf(buf, size, text, args);
	65	} while (i == size);
	66
	67	va_end(args);
	68
	69	newtCenteredWindow(width, height, title);
	70
	71	b = newtCompactButton(width - 15 ,height - 2, ctr[TR_OK]);
	72	c = newtCheckbox(3, height - 2, ctr[TR_LICENSE_ACCEPT], ' ', " *", &checkbox);
	73
	74	t = newtTextbox(1, 1, width - 2, height - 4, NEWT_TEXTBOX_WRAP+NEWT_TEXTBOX_SCROLL);
	75	newtTextboxSetText(t, buf);
	76
	77	f = newtForm(NULL, NULL, 0);
	78	free(buf);
	79
	80	newtFormAddComponent(f, c);
	81	newtFormAddComponent(f, b);
	82	newtFormAddComponent(f, t);
	83
	84	newtRunForm(f);
	85	if (checkbox=='*') rc=1;
	86	newtFormDestroy(f);
	87	return rc;
	88	}
	89
	90	int disclaimerbox(char *message)
	91	{
	92	int rc;
	93	char title[STRING_SIZE];
	94
	95	sprintf (title, "%s v%s - %s", NAME, VERSION, SLOGAN);
	96	rc = scrollmsgbox(75, 20, title, message);
	97	newtPopWindow();
	98
	99	return rc;
	100	}
	101
	102
3d6e1202 MT	103	void statuswindow(int width, int height, char title, char text, ...)
	104	{
	105	newtComponent t, f;
	106	char *buf = NULL;
	107	int size = 0;
	108	int i = 0;
	109	va_list args;
	110
	111	va_start(args, text);
	112
	113	do {
	114	size += 1000;
	115	if (buf) free(buf);
	116	buf = malloc(size);
	117	i = vsnprintf(buf, size, text, args);
	118	} while (i == size);
	119
	120	va_end(args);
	121
	122	newtCenteredWindow(width, height, title);
	123
	124	t = newtTextbox(1, 1, width - 2, height - 2, NEWT_TEXTBOX_WRAP);
	125	newtTextboxSetText(t, buf);
	126	f = newtForm(NULL, NULL, 0);
	127
	128	free(buf);
	129
	130	newtFormAddComponent(f, t);
	131
	132	newtDrawForm(f);
	133	newtRefresh();
	134	newtFormDestroy(f);
	135	}
	136
	137	int runcommandwithstatus(char command, char message)
	138	{
	139	int rc;
	140	char title[STRING_SIZE];
	141
	142	sprintf (title, "%s v%s - %s", NAME, VERSION, SLOGAN);
	143	statuswindow(60, 4, title, message);
	144	rc = mysystem(command);
	145	newtPopWindow();
	146
	147	return rc;
	148	}
	149
	150	int runhiddencommandwithstatus(char command, char message)
	151	{
	152	int rc;
	153	char title[STRING_SIZE];
	154	char mycommand[STRING_SIZE];
	155
	156	sprintf (title, "%s v%s - %s", NAME, VERSION, SLOGAN);
	157	statuswindow(60, 4, title, message);
	158	snprintf(mycommand, STRING_SIZE, "%s >>%s 2>>%s", command, mylog, mylog);
	159	fprintf(flog, "Running command: *** HIDDEN ***\n");
	160	rc = system(mycommand);
	161	newtPopWindow();
	162
	163	return rc;
	164	}
	165
	166	/* This one borrowed from redhat installer. */
167	int runcommandwithprogress(int width, int height, char title, char command,
168	int lines, char *text, ...)
169	{
170	newtComponent t, f, s;
171	char *buf = NULL;
172	int size = 0;
173	int i = 0;
174	va_list args;
175	int rc = 0;
176	FILE *p;
177	char buffer[STRING_SIZE];
178	int progress = 0;
179	char mycommand[STRING_SIZE];
180
181	va_start(args, text);
182
183	do {
184	size += 1000;
185	if (buf) free(buf);
186	buf = malloc(size);
187	i = vsnprintf(buf, size, text, args);
188	} while (i == size);
189
190	va_end(args);
191
192	newtCenteredWindow(width, height, title);
193
194	t = newtTextbox(1, 1, width - 2, height - 2, NEWT_TEXTBOX_WRAP);
195	newtTextboxSetText(t, buf);
196	f = newtForm(NULL, NULL, 0);
197
198	free(buf);
199
200	newtFormAddComponent(f, t);
201
202	s = newtScale(1, 3, width - 2, lines);
203	newtScaleSet(s, progress);
204
205	newtFormAddComponent(f, s);
206
207	newtDrawForm(f);
208	newtRefresh();
209
210	snprintf(mycommand, STRING_SIZE, "%s 2>>%s", command, mylog);
211	fprintf(flog, "Running command: %s\n", command);
212
213	if (!(p = popen(command, "r")))
214	{
215	rc = 1;
216	goto EXIT;
217	}
218	setvbuf(p, NULL, _IOLBF, 255);
219
220	while (fgets(buffer, STRING_SIZE, p))
221	{
222	newtScaleSet(s, ++progress);
223	newtRefresh();
224	fprintf(flog, "%s", buffer);
225	}
226
227	rc = pclose(p);
228
229	EXIT:
230	newtFormDestroy(f);
231	newtPopWindow();
232
233	return rc;
234	}
235
236	int checkformodule(char *module)
237	{
238	FILE *file;
239	char buffer[STRING_SIZE];
240	int result = 0;
241
242	if (!(file = fopen("/proc/modules", "r")))
243	{
244	fprintf(flog, "Unable to open /proc/modules in checkformodule()\n");
245	return 0;
246	}
247
248	while (fgets(buffer, STRING_SIZE, file))
249	{
250	if (strncmp(buffer, module, strlen(module)) == 0)
251	{
252	if (buffer[strlen(module)] == ' ')
253	{
254	result = 1;
255	goto EXIT;
256	}
257	}
258	}
259
260	EXIT:
261	fclose(file);
262
263	return result;
264	}
265
266	int _replace_string(char string[], char from, char to)
267	{
268	int fromlen = strlen(from);
269	int tolen = strlen(to);
270	char start, p1, *p2;
271	for(start = string; *start != '\0'; start++)
272	{
273	p1 = from;
274	p2 = start;
275	while(*p1 != '\0')
276	{
277	if(p1 != p2)
278	break;
279	p1++;
280	p2++;
281	}
282	if(*p1 == '\0')
283	{
284	if(fromlen != tolen)
285	{
286	memmove(start + tolen, start + fromlen,
287	strlen(start + fromlen) + 1);
288	}
289	for(p1 = to; *p1 != '\0'; p1++)
290	start++ = p1;
291	return 1;
292	}
293	}
294	return 0;
295	}
296
297	int replace(char filename1[], char from, char to)
298	{
299	FILE file1, file2;
300	char filename2[1000];
301	char temp[1000];
302	int ret = 0;
303
304	/* Open the source and destination files */
305	strcpy (filename2, filename1);
306	strcat (filename2, ".new");
307	if (!(file1 = fopen (filename1, "r"))) return 1;
308	if (!(file2 = fopen (filename2, "w"))) {
309	fclose(file1);
310	return -1;
311	}
312
313	/* Start reading in lines */
314	while (fgets (temp, 1000, file1) != NULL) {
315
316	if (strlen(to) > 0) {
317	/* Replace string */
318	ret = _replace_string (temp, from, to);
319
320	/* Write string to new file */
321	fputs(temp, file2);
322	} else {
323	/* Remove string when to is NULL */
324	if (!strstr(temp, from))
325	fputs(temp, file2);
326	}
327	}
328
329	/* Close source and destination */
330	fclose (file1);
331	fclose (file2);
332
333	/* Move the file */
334	rename (filename2, filename1);
335
336	return (ret);
337	}
338
339	/* Include enabled languages */
340	#ifdef LANG_EN_ONLY
341	#include "lang_en.c"
3d6e1202 MT	342	#else
	343	#include "lang_de.c"
	344	#include "lang_en.c"
cf4dd3c0	345	#include "lang_es.c"
462515e4	346	#include "lang_fr.c"
b6c9668f	347	#include "lang_pl.c"
2bb7b134	348	#include "lang_ru.c"
3d6e1202	349	#endif
b4e381a8	350
3d6e1202 MT	351	// returns a pointer to the actual running version number of IPFire.
	352	// Successive updates increase effective version but not VERSION !
	353	char g_title[STRING_SIZE] = "";
	354	char* get_version(void) {
	355	FILE *f_title;
	356	if ((f_title = fopen ("/etc/issue", "r"))) {
	357	fgets (g_title, STRING_SIZE, f_title);
	358	fclose (f_title);
	359	if (g_title[strlen(g_title) - 1] == '\n') g_title[strlen(g_title) - 1] = '\0';
	360	} else {
b4e381a8	361	sprintf (g_title, "%s %s - %s", NAME, VERSION, SLOGAN);
3d6e1202 MT	362	}
	363	return g_title;
	364	}