fw_builder/bootsplash/splash.c

/* Splash control program.
 * 
 * (c) 2001, 2002, 2003 by Stefan Reinauer <stepan@suse.de>
 * 
 * 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.
 *
 */

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <libgen.h>
#include <getopt.h>


#define PROCSPLASH "/proc/splash"
#define BUFSIZE 4096
#if 1
#define DEBUG(x...)
#else
#define DEBUG(x...) printf(x)
#endif

long unit = 0;
long version = 1;
long state = -1;
long fgcolor = -1;
long bgcolor = -1;
long tx = -1;
long ty = -1;
long tw = -1;
long th = -1;
long px = 0;
long py = 0;
long pw = 0;
long ph = 0;
long pr = 0;
long pg = 0;
long pb = 0;
long pa = 160;
long pf = 1;
long pc = 0x141464;
long ptl = 0xffff;
long pbr = 0x00;
long ax = 0;
long ay = 0;
long progress = 0;
long overpaintok = 0;
long percent = 0;
long text = 0;
char *jpgfile = 0;
char *silentjpgfile = 0;
char splashdscname[512];

int boxcount;
unsigned char boxes[12 * 256];
int sboxcount;
unsigned char sboxes[12 * 256];

struct parstab {
	char *name;
	long *val;
	char **str;
} parstab[] = {
	{ "unit", &unit }, 
	{ "version", &version }, 
	{ "state", &state }, 
	{ "fgcolor", &fgcolor }, 
	{ "bgcolor", &bgcolor },
	    /* v1+ */
	{ "tx", &tx }, 
	{ "ty", &ty }, 
	{ "tw", &tw }, 
	{ "th", &th },
	    /* v2+ */
	{ "px", &px }, 
	{ "py", &py }, 
	{ "pw", &pw }, 
	{ "ph", &ph }, 
	{ "pr", &pr }, 
	{ "pg", &pg }, 
	{ "pb", &pb }, 
	{ "ax", &ax }, 
	{ "ay", &ay },
	    /* v3+ */
	    /* independant */
	{ "progress_enable", &progress }, 
	{ "progress_x", &progress }, 
	{ "progress_y", &progress }, 
	{ "progress_width", &progress }, 
	{ "progress_height", &progress }, 
	{ "progress_fgcolor", &progress }, 
	{ "progress_bgcolor", &progress }, 
	{ "text_size", &text }, 
	{ "text_color", &text }, 
	{ "text_x", &text }, 
	{ "text_y", &text }, 
	{ "text_font", (long *) 0 }, 
	{ "silentjpeg", (long *) 0, &silentjpgfile }, 
	{ "percent", &percent }, 
	{ "overpaintok", &overpaintok }, 
	{ "jpeg", (long *) 0, &jpgfile }, 
	{ (char *) 0, (long *) 0 }
};

void parsebox(char *pl)
{
	int co[4];
	int i, j, c, d = 0;
	char cols[16];
	unsigned char *bp;
	int boxcnt;
	int isibox = 0;
	int *boxcntp;
	unsigned char *boxptr;
	char *p = pl + 3;
	int noover = 0;
	int hidemax = 0;

	boxcntp = &boxcount;
	boxptr = boxes;
	for (i = 0; i < 4; i++) {
		if (*p != ' ' && *p != '\t' && *p != '=') {
			fprintf(stderr, "syntax error: '%c' %s\n", *p, pl);
			exit(1);
		}
		while (*p == ' ' || *p == '\t' || *p == '=')
			p++;
		if (i == 0 && !strncmp(p, "silent", 6)) {
			i--;
			boxcntp = &sboxcount;
			boxptr = sboxes;
			p += 6;
			continue;
		}
		if (i == 0 && !strncmp(p, "inter", 5)) {
			i--;
			isibox = 1;
			p += 5;
			continue;
		}
		if (i == 0 && !strncmp(p, "noover", 6)) {
			i--;
			noover = 1;
			p += 6;
			continue;
		}
		if (i == 0 && !strncmp(p, "hidemax", 7)) {
			i--;
			hidemax = 1;
			p += 7;
			continue;
		}
		co[i] = strtol(p, (char **) NULL, 0);
		while (*p == 'x' || (*p >= '0' && *p <= '9')
		       || (*p >= 'a' && *p <= 'f') || (*p >= 'A'
						       && *p <= 'F'))
			p++;
	}
	for (i = 0; i < 4; i++) {
		if (*p != ' ' && *p != '\t') {
			fprintf(stderr, "syntax error: %s\n", pl);
			exit(1);
		}
		while (*p == ' ' || *p == '\t')
			p++;
		if (i == 1 && *p == 0)
			break;
		if (*p++ != '#') {
			fprintf(stderr, "syntax error: %s\n", pl);
			exit(1);
		}
		for (j = 0; j < 8; j++) {
			c = *p++;
			if (c >= '0' && c <= '9')
				c -= '0';
			else if (c >= 'a' && c <= 'f')
				c -= 'a' - 10;
			else if (c >= 'A' && c <= 'F')
				c -= 'A' - 10;
			else {
				fprintf(stderr, "syntax error: %s\n", pl);
				exit(1);
			}
			if (!(j & 1)) {
				d = c;
				continue;
			}
			c += d << 4;
			cols[i * 4 + (j >> 1)] = c;
			if (j == 5 && (*p == 0 || *p == ' ' || *p == '\t')) {
				cols[i * 4 + 3] = 255;
				break;
			}
		}
		if (*p == 0 && i == 0) {
			i = 1;
			break;
		}
	}
	while (*p == ' ' || *p == '\t')
		p++;
	if (*p) {
		fprintf(stderr, "syntax error: %s\n", pl);
		exit(1);
	}
	boxcnt = *boxcntp;
	if (boxcnt >= 254) {
		fprintf(stderr, "too many boxes\n");
		exit(1);
	}
	bp = boxptr + 12 * boxcnt++;
	if (isibox)
		co[0] = ~co[0];
	if (i > 1) {
		co[1] = ~co[1];
		boxcnt++;
	}
	if (noover)
		co[2] = ~co[2];
	if (hidemax)
		co[3] = ~co[3];
	*bp++ = co[0] & 255;
	*bp++ = co[0] >> 8;
	*bp++ = co[1] & 255;
	*bp++ = co[1] >> 8;
	*bp++ = co[2] & 255;
	*bp++ = co[2] >> 8;
	*bp++ = co[3] & 255;
	*bp++ = co[3] >> 8;
	for (j = 0; j < i * 4; j++)
		*bp++ = cols[j];
	*boxcntp = boxcnt;
}

void setsplash(char *cfgfile, int filterflag, int verbose_only)
{
	struct stat stb;
	char buf[256];
	char *p;
	int l, size, fd;
	FILE *fp = 0;
	FILE *sfp = 0;
	struct parstab *pt;
	unsigned char *pic;
	int silentl = 0;

	if (cfgfile) {
		if ((fp = fopen(cfgfile, "r")) == 0) {
			perror(cfgfile);
			exit(1);
		}
		while (fgets(buf, sizeof(buf), fp)) {
			l = strlen(buf);
			if (l == 0)
				continue;
			if (l == sizeof(buf) - 1) {
				fprintf(stderr, "line too long\n");
				exit(1);
			}
			buf[--l] = 0;
			while (l
			       && (buf[l - 1] == ' '
				   || (buf[l - 1] == '\t')))
				buf[--l] = 0;
			for (p = buf; *p == ' ' || *p == '\t'; p++);
			if (*p == 0 || *p == '#')
				continue;
			if (!strncmp(p, "box", 3)) {
				parsebox(p);
				continue;
			}
			for (pt = parstab; pt->name; pt++) {
				l = strlen(pt->name);
				if (!strncmp(p, pt->name, l)
				    && (p[l] == ' ' || p[l] == '\t'
					|| p[l] == '='))
					break;
			}
			if (!pt->name) {
				fprintf(stderr, "syntax error: %s\n", p);
				exit(1);
			}
			while (p[l] == ' ' || p[l] == '\t')
				l++;
			if (p[l++] != '=') {
				fprintf(stderr, "syntax error: %s\n", p);
				exit(1);
			}
			while (p[l] == ' ' || p[l] == '\t')
				l++;
			if (pt->val)
				*pt->val =
				    strtol(p + l, (char **) NULL, 0);
			else
				*pt->str = strdup(p + l);
		}
		fclose(fp);
		if (!jpgfile) {
			l = strlen(cfgfile);
			if (l > 4 && !strcmp(cfgfile + l - 4, ".cfg")) {
				jpgfile = strdup(cfgfile);
				strcpy(jpgfile + l - 4, ".jpg");
				p = strstr(jpgfile, "config");
				if (p)
					strncpy(p, "images", 6);
			}
		}

		if (tx == 0 && ty == 0 && tw == 0 && th == 0) {
			tx = px + 8;
			ty = py + 4;
			tw = pw - 16;
			th = ph - 8;
		}

		if (jpgfile
		    && (*jpgfile == 0 || tx < 0 || ty < 0 || tw <= 0
			|| th <= 0)) {
			free(jpgfile);
			jpgfile = 0;
		}
	}

	if (verbose_only)
		silentjpgfile = NULL;


	if (silentjpgfile && jpgfile) {
		if ((sfp = fopen(silentjpgfile, "r")) == 0) {
			perror(silentjpgfile);
			exit(1);
		}
		if (fstat(fileno(sfp), &stb) == -1) {
			perror("fstat");
			exit(1);
		}
		silentl = stb.st_size;
	}

	if (jpgfile) {
		if ((fp = fopen(jpgfile, "r")) == 0) {
			perror(jpgfile);
			exit(1);
		}
		if (fstat(fileno(fp), &stb) == -1) {
			perror("fstat");
			exit(1);
		}
		l = stb.st_size;
		pic =
		    calloc(47 + l + silentl + boxcount * 12 +
			   sboxcount * 12, 1);
		if (pic == 0) {
			fprintf(stderr, "Out of memory.\n");
			exit(1);
		}
		if (fread(pic + 47 + boxcount * 12, l, 1, fp) != 1) {
			perror("fread");
			exit(1);
		}
		if (silentjpgfile) {
			if (fread
			    (pic + 47 + l + boxcount * 12 + sboxcount * 12,
			     silentl, 1, sfp) != 1) {
				perror("fread");
				exit(1);
			}
			fclose(sfp);
			if (sboxcount)
				memmove(pic + 47 + l + boxcount * 12,
					sboxes, sboxcount * 12);
			silentl += sboxcount * 12;
			l += silentl;
		}
		fclose(fp);
	} else {
		l = 0;
		pic = calloc(47, 1);
		if (pic == 0) {
			fprintf(stderr, "Out of memory.\n");
			exit(1);
		}
	}
	size = l;
	if (version < 1 || version > 3) {
		fprintf(stderr, "Illegal version: %ld\n", version);
		exit(1);
	}
	if (version == 1 && unit != 0) {
		/* convert to version 2 */
		tx *= 8;
		ty *= 16;
		tw *= 8;
		th *= 16;
		px = tx + 10;
		py = ty + 10;
		pw = tw - 20;
		ph = th - 20;
		pr = pg = pb = 240;
		state = 1;
		fgcolor = 0;
		bgcolor = 15;
		version = 2;
	}
	if (version == 1) {
		/* write version 1 file */
		strcpy(pic, "BOOTSPL1");
		pic[8] = tx;
		pic[9] = tx >> 8;
		pic[10] = ty;
		pic[11] = ty >> 8;
		pic[12] = tw;
		pic[13] = tw >> 8;
		pic[14] = th;
		pic[15] = th >> 8;
		pic[16] = size;
		pic[17] = size >> 8;
		pic[18] = size >> 16;
		pic[19] = size >> 24;
		if (l > 0)
			memmove(pic + 20, pic + 47, l);
		l += 20;
	} else if (version == 2) {
		/* write version 2 file */
		strcpy(pic, "BOOTSPL2");
		pic[8] = unit;
		pic[9] = state;
		pic[10] = fgcolor;
		pic[11] = bgcolor;
		if (cfgfile && size == 0
		    && (state != -1 || fgcolor != -1 || bgcolor != -1))
			size = -1;
		pic[12] = size;
		pic[13] = size >> 8;
		pic[14] = size >> 16;
		pic[15] = size >> 24;
		pic[16] = tx;
		pic[17] = tx >> 8;
		pic[18] = ty;
		pic[19] = ty >> 8;
		pic[20] = tw;
		pic[21] = tw >> 8;
		pic[22] = th;
		pic[23] = th >> 8;
		pic[24] = px;
		pic[25] = px >> 8;
		pic[26] = py;
		pic[27] = py >> 8;
		pic[28] = pw;
		pic[29] = pw >> 8;
		pic[30] = ph;
		pic[31] = ph >> 8;
		pic[32] = pr;
		pic[33] = pg;
		pic[34] = pb;
		if (l > 0)
			memmove(pic + 35, pic + 47, l);
		l += 35;
	} else {		/* version 3 */
		strcpy(pic, "BOOTSPL3");
		pic[8] = unit;
		pic[9] = state;
		pic[10] = fgcolor;
		pic[11] = bgcolor;
		size += boxcount * 12;
		if (cfgfile && size == 0
		    && (state != -1 || fgcolor != -1 || bgcolor != -1))
			size = -1;
		pic[12] = size;
		pic[13] = size >> 8;
		pic[14] = size >> 16;
		pic[15] = size >> 24;
		pic[16] = tx;
		pic[17] = tx >> 8;
		pic[18] = ty;
		pic[19] = ty >> 8;
		pic[20] = tw;
		pic[21] = tw >> 8;
		pic[22] = th;
		pic[23] = th >> 8;
		pic[24] = boxcount;
		pic[25] = boxcount >> 8;
		pic[28] = silentl;
		pic[29] = silentl >> 8;
		pic[30] = silentl >> 16;
		pic[31] = silentl >> 24;
		pic[32] = sboxcount;
		pic[33] = sboxcount >> 8;
		pic[34] = percent;
		pic[35] = percent >> 8;
		pic[36] = overpaintok;
		pic[37] = 0;	/* numpalette */
		if (l > 0)
			memmove(pic + 38 + boxcount * 12,
				pic + 47 + boxcount * 12, l);
		if (boxcount)
			memmove(pic + 38, boxes, boxcount * 12);
		l += 38 + boxcount * 12;
	}

	if (filterflag)
		fd = 1;
	else if ((fd = open(PROCSPLASH, O_WRONLY)) == -1) {
		perror(PROCSPLASH);
		exit(1);
	}
	if (write(fd, pic, l) != l) {
		perror("write");
		exit(1);
	}
	if (!filterflag)
		close(fd);
	free(pic);
}

int main(int argc, char *argv[])
{
	int procsplash, c;
	int setflag = 0;
	int errflag = 0;
	int filterflag = 0;
	int verbose_only = 0;
	unsigned char *readbuffer;

	while ((c = getopt(argc, argv, "fsu:n")) != EOF) {
		switch (c) {
		case 's':
			setflag = 1;
			break;
		case 'f':
			filterflag = 1;
			break;
		case 'u':
			unit = atoi(optarg);
			break;
		case 'n':
			verbose_only = 1;
			break;
		case '?':
			errflag = 1;
			break;
		}
	}

	if (errflag
	    || (argc != optind + 1 && (argc != optind || !setflag))) {
		printf("Usage: %s -s [-u unit] -n [cfgfile]\n", argv[0]);
		return 0;
	}

	readbuffer = malloc(BUFSIZE);

	if (!readbuffer) {
		DEBUG("splash: Not enough memory.\n");
		return -ENOMEM;
	}

	if (!setflag || !filterflag) {
		procsplash = open(PROCSPLASH, O_RDONLY);
		if (procsplash < 0) {
			if (setflag) {
				perror(PROCSPLASH);
				exit(1);
			}
			DEBUG("splash: File %s not available.\n",
			      PROCSPLASH);
			return 0;
		}

		if (read(procsplash, readbuffer, BUFSIZE) < 0) {
			if (setflag)
				perror("read");
			DEBUG("splash: Read error in file %s.\n",
			      PROCSPLASH);
			return -EBUSY;
		}
		close(procsplash);
	}
	if (setflag) {
		if (!filterflag
		    && !strncmp(readbuffer, "Splash screen v0", 16)) {
			fprintf(stderr,
				"Your kernel support for the bootsplash is too old. Get the new version from http://www.bootsplash.org/\n");
			exit(1);
		}
		setsplash(argc > optind ? argv[optind] : 0, filterflag,
			  verbose_only);
		exit(0);
	}

	return 0;
}
1	niro	658	/* Splash control program.
2			*
3			* (c) 2001, 2002, 2003 by Stefan Reinauer <stepan@suse.de>
4			*
5			* This program is free software; you can redistribute it and/or
6			* modify it under the terms of the GNU General Public License
7			* as published by the Free Software Foundation; either version
8			* 2 of the License, or (at your option) any later version.
9			*
10			*/
11
12			#include <sys/types.h>
13			#include <sys/stat.h>
14			#include <fcntl.h>
15			#include <unistd.h>
16			#include <errno.h>
17			#include <stdio.h>
18			#include <string.h>
19			#include <stdlib.h>
20			#include <libgen.h>
21			#include <getopt.h>
22
23
24			#define PROCSPLASH "/proc/splash"
25			#define BUFSIZE 4096
26			#if 1
27			#define DEBUG(x...)
28			#else
29			#define DEBUG(x...) printf(x)
30			#endif
31
32			long unit = 0;
33			long version = 1;
34			long state = -1;
35			long fgcolor = -1;
36			long bgcolor = -1;
37			long tx = -1;
38			long ty = -1;
39			long tw = -1;
40			long th = -1;
41			long px = 0;
42			long py = 0;
43			long pw = 0;
44			long ph = 0;
45			long pr = 0;
46			long pg = 0;
47			long pb = 0;
48			long pa = 160;
49			long pf = 1;
50			long pc = 0x141464;
51			long ptl = 0xffff;
52			long pbr = 0x00;
53			long ax = 0;
54			long ay = 0;
55			long progress = 0;
56			long overpaintok = 0;
57			long percent = 0;
58			long text = 0;
59			char *jpgfile = 0;
60			char *silentjpgfile = 0;
61			char splashdscname[512];
62
63			int boxcount;
64			unsigned char boxes[12 * 256];
65			int sboxcount;
66			unsigned char sboxes[12 * 256];
67
68			struct parstab {
69			char *name;
70			long *val;
71			char **str;
72			} parstab[] = {
73			{ "unit", &unit },
74			{ "version", &version },
75			{ "state", &state },
76			{ "fgcolor", &fgcolor },
77			{ "bgcolor", &bgcolor },
78			/* v1+ */
79			{ "tx", &tx },
80			{ "ty", &ty },
81			{ "tw", &tw },
82			{ "th", &th },
83			/* v2+ */
84			{ "px", &px },
85			{ "py", &py },
86			{ "pw", &pw },
87			{ "ph", &ph },
88			{ "pr", &pr },
89			{ "pg", &pg },
90			{ "pb", &pb },
91			{ "ax", &ax },
92			{ "ay", &ay },
93			/* v3+ */
94			/* independant */
95			{ "progress_enable", &progress },
96			{ "progress_x", &progress },
97			{ "progress_y", &progress },
98			{ "progress_width", &progress },
99			{ "progress_height", &progress },
100			{ "progress_fgcolor", &progress },
101			{ "progress_bgcolor", &progress },
102			{ "text_size", &text },
103			{ "text_color", &text },
104			{ "text_x", &text },
105			{ "text_y", &text },
106			{ "text_font", (long *) 0 },
107			{ "silentjpeg", (long *) 0, &silentjpgfile },
108			{ "percent", &percent },
109			{ "overpaintok", &overpaintok },
110			{ "jpeg", (long *) 0, &jpgfile },
111			{ (char ) 0, (long ) 0 }
112			};
113
114			void parsebox(char *pl)
115			{
116			int co[4];
117			int i, j, c, d = 0;
118			char cols[16];
119			unsigned char *bp;
120			int boxcnt;
121			int isibox = 0;
122			int *boxcntp;
123			unsigned char *boxptr;
124			char *p = pl + 3;
125			int noover = 0;
126			int hidemax = 0;
127
128			boxcntp = &boxcount;
129			boxptr = boxes;
130			for (i = 0; i < 4; i++) {
131			if (p != ' ' && p != '\t' && *p != '=') {
132			fprintf(stderr, "syntax error: '%c' %s\n", *p, pl);
133			exit(1);
134			}
135			while (p == ' ' \|\| p == '\t' \|\| *p == '=')
136			p++;
137			if (i == 0 && !strncmp(p, "silent", 6)) {
138			i--;
139			boxcntp = &sboxcount;
140			boxptr = sboxes;
141			p += 6;
142			continue;
143			}
144			if (i == 0 && !strncmp(p, "inter", 5)) {
145			i--;
146			isibox = 1;
147			p += 5;
148			continue;
149			}
150			if (i == 0 && !strncmp(p, "noover", 6)) {
151			i--;
152			noover = 1;
153			p += 6;
154			continue;
155			}
156			if (i == 0 && !strncmp(p, "hidemax", 7)) {
157			i--;
158			hidemax = 1;
159			p += 7;
160			continue;
161			}
162			co[i] = strtol(p, (char **) NULL, 0);
163			while (p == 'x' \|\| (p >= '0' && *p <= '9')
164			\|\| (p >= 'a' && p <= 'f') \|\| (*p >= 'A'
165			&& *p <= 'F'))
166			p++;
167			}
168			for (i = 0; i < 4; i++) {
169			if (p != ' ' && p != '\t') {
170			fprintf(stderr, "syntax error: %s\n", pl);
171			exit(1);
172			}
173			while (p == ' ' \|\| p == '\t')
174			p++;
175			if (i == 1 && *p == 0)
176			break;
177			if (*p++ != '#') {
178			fprintf(stderr, "syntax error: %s\n", pl);
179			exit(1);
180			}
181			for (j = 0; j < 8; j++) {
182			c = *p++;
183			if (c >= '0' && c <= '9')
184			c -= '0';
185			else if (c >= 'a' && c <= 'f')
186			c -= 'a' - 10;
187			else if (c >= 'A' && c <= 'F')
188			c -= 'A' - 10;
189			else {
190			fprintf(stderr, "syntax error: %s\n", pl);
191			exit(1);
192			}
193			if (!(j & 1)) {
194			d = c;
195			continue;
196			}
197			c += d << 4;
198			cols[i * 4 + (j >> 1)] = c;
199			if (j == 5 && (p == 0 \|\| p == ' ' \|\| *p == '\t')) {
200			cols[i * 4 + 3] = 255;
201			break;
202			}
203			}
204			if (*p == 0 && i == 0) {
205			i = 1;
206			break;
207			}
208			}
209			while (p == ' ' \|\| p == '\t')
210			p++;
211			if (*p) {
212			fprintf(stderr, "syntax error: %s\n", pl);
213			exit(1);
214			}
215			boxcnt = *boxcntp;
216			if (boxcnt >= 254) {
217			fprintf(stderr, "too many boxes\n");
218			exit(1);
219			}
220			bp = boxptr + 12 * boxcnt++;
221			if (isibox)
222			co[0] = ~co[0];
223			if (i > 1) {
224			co[1] = ~co[1];
225			boxcnt++;
226			}
227			if (noover)
228			co[2] = ~co[2];
229			if (hidemax)
230			co[3] = ~co[3];
231			*bp++ = co[0] & 255;
232			*bp++ = co[0] >> 8;
233			*bp++ = co[1] & 255;
234			*bp++ = co[1] >> 8;
235			*bp++ = co[2] & 255;
236			*bp++ = co[2] >> 8;
237			*bp++ = co[3] & 255;
238			*bp++ = co[3] >> 8;
239			for (j = 0; j < i * 4; j++)
240			*bp++ = cols[j];
241			*boxcntp = boxcnt;
242			}
243
244			void setsplash(char *cfgfile, int filterflag, int verbose_only)
245			{
246			struct stat stb;
247			char buf[256];
248			char *p;
249			int l, size, fd;
250			FILE *fp = 0;
251			FILE *sfp = 0;
252			struct parstab *pt;
253			unsigned char *pic;
254			int silentl = 0;
255
256			if (cfgfile) {
257			if ((fp = fopen(cfgfile, "r")) == 0) {
258			perror(cfgfile);
259			exit(1);
260			}
261			while (fgets(buf, sizeof(buf), fp)) {
262			l = strlen(buf);
263			if (l == 0)
264			continue;
265			if (l == sizeof(buf) - 1) {
266			fprintf(stderr, "line too long\n");
267			exit(1);
268			}
269			buf[--l] = 0;
270			while (l
271			&& (buf[l - 1] == ' '
272			\|\| (buf[l - 1] == '\t')))
273			buf[--l] = 0;
274			for (p = buf; p == ' ' \|\| p == '\t'; p++);
275			if (p == 0 \|\| p == '#')
276			continue;
277			if (!strncmp(p, "box", 3)) {
278			parsebox(p);
279			continue;
280			}
281			for (pt = parstab; pt->name; pt++) {
282			l = strlen(pt->name);
283			if (!strncmp(p, pt->name, l)
284			&& (p[l] == ' ' \|\| p[l] == '\t'
285			\|\| p[l] == '='))
286			break;
287			}
288			if (!pt->name) {
289			fprintf(stderr, "syntax error: %s\n", p);
290			exit(1);
291			}
292			while (p[l] == ' ' \|\| p[l] == '\t')
293			l++;
294			if (p[l++] != '=') {
295			fprintf(stderr, "syntax error: %s\n", p);
296			exit(1);
297			}
298			while (p[l] == ' ' \|\| p[l] == '\t')
299			l++;
300			if (pt->val)
301			*pt->val =
302			strtol(p + l, (char **) NULL, 0);
303			else
304			*pt->str = strdup(p + l);
305			}
306			fclose(fp);
307			if (!jpgfile) {
308			l = strlen(cfgfile);
309			if (l > 4 && !strcmp(cfgfile + l - 4, ".cfg")) {
310			jpgfile = strdup(cfgfile);
311			strcpy(jpgfile + l - 4, ".jpg");
312			p = strstr(jpgfile, "config");
313			if (p)
314			strncpy(p, "images", 6);
315			}
316			}
317
318			if (tx == 0 && ty == 0 && tw == 0 && th == 0) {
319			tx = px + 8;
320			ty = py + 4;
321			tw = pw - 16;
322			th = ph - 8;
323			}
324
325			if (jpgfile
326			&& (*jpgfile == 0 \|\| tx < 0 \|\| ty < 0 \|\| tw <= 0
327			\|\| th <= 0)) {
328			free(jpgfile);
329			jpgfile = 0;
330			}
331			}
332
333			if (verbose_only)
334			silentjpgfile = NULL;
335
336
337			if (silentjpgfile && jpgfile) {
338			if ((sfp = fopen(silentjpgfile, "r")) == 0) {
339			perror(silentjpgfile);
340			exit(1);
341			}
342			if (fstat(fileno(sfp), &stb) == -1) {
343			perror("fstat");
344			exit(1);
345			}
346			silentl = stb.st_size;
347			}
348
349			if (jpgfile) {
350			if ((fp = fopen(jpgfile, "r")) == 0) {
351			perror(jpgfile);
352			exit(1);
353			}
354			if (fstat(fileno(fp), &stb) == -1) {
355			perror("fstat");
356			exit(1);
357			}
358			l = stb.st_size;
359			pic =
360			calloc(47 + l + silentl + boxcount * 12 +
361			sboxcount * 12, 1);
362			if (pic == 0) {
363			fprintf(stderr, "Out of memory.\n");
364			exit(1);
365			}
366			if (fread(pic + 47 + boxcount * 12, l, 1, fp) != 1) {
367			perror("fread");
368			exit(1);
369			}
370			if (silentjpgfile) {
371			if (fread
372			(pic + 47 + l + boxcount * 12 + sboxcount * 12,
373			silentl, 1, sfp) != 1) {
374			perror("fread");
375			exit(1);
376			}
377			fclose(sfp);
378			if (sboxcount)
379			memmove(pic + 47 + l + boxcount * 12,
380			sboxes, sboxcount * 12);
381			silentl += sboxcount * 12;
382			l += silentl;
383			}
384			fclose(fp);
385			} else {
386			l = 0;
387			pic = calloc(47, 1);
388			if (pic == 0) {
389			fprintf(stderr, "Out of memory.\n");
390			exit(1);
391			}
392			}
393			size = l;
394			if (version < 1 \|\| version > 3) {
395			fprintf(stderr, "Illegal version: %ld\n", version);
396			exit(1);
397			}
398			if (version == 1 && unit != 0) {
399			/* convert to version 2 */
400			tx *= 8;
401			ty *= 16;
402			tw *= 8;
403			th *= 16;
404			px = tx + 10;
405			py = ty + 10;
406			pw = tw - 20;
407			ph = th - 20;
408			pr = pg = pb = 240;
409			state = 1;
410			fgcolor = 0;
411			bgcolor = 15;
412			version = 2;
413			}
414			if (version == 1) {
415			/* write version 1 file */
416			strcpy(pic, "BOOTSPL1");
417			pic[8] = tx;
418			pic[9] = tx >> 8;
419			pic[10] = ty;
420			pic[11] = ty >> 8;
421			pic[12] = tw;
422			pic[13] = tw >> 8;
423			pic[14] = th;
424			pic[15] = th >> 8;
425			pic[16] = size;
426			pic[17] = size >> 8;
427			pic[18] = size >> 16;
428			pic[19] = size >> 24;
429			if (l > 0)
430			memmove(pic + 20, pic + 47, l);
431			l += 20;
432			} else if (version == 2) {
433			/* write version 2 file */
434			strcpy(pic, "BOOTSPL2");
435			pic[8] = unit;
436			pic[9] = state;
437			pic[10] = fgcolor;
438			pic[11] = bgcolor;
439			if (cfgfile && size == 0
440			&& (state != -1 \|\| fgcolor != -1 \|\| bgcolor != -1))
441			size = -1;
442			pic[12] = size;
443			pic[13] = size >> 8;
444			pic[14] = size >> 16;
445			pic[15] = size >> 24;
446			pic[16] = tx;
447			pic[17] = tx >> 8;
448			pic[18] = ty;
449			pic[19] = ty >> 8;
450			pic[20] = tw;
451			pic[21] = tw >> 8;
452			pic[22] = th;
453			pic[23] = th >> 8;
454			pic[24] = px;
455			pic[25] = px >> 8;
456			pic[26] = py;
457			pic[27] = py >> 8;
458			pic[28] = pw;
459			pic[29] = pw >> 8;
460			pic[30] = ph;
461			pic[31] = ph >> 8;
462			pic[32] = pr;
463			pic[33] = pg;
464			pic[34] = pb;
465			if (l > 0)
466			memmove(pic + 35, pic + 47, l);
467			l += 35;
468			} else { /* version 3 */
469			strcpy(pic, "BOOTSPL3");
470			pic[8] = unit;
471			pic[9] = state;
472			pic[10] = fgcolor;
473			pic[11] = bgcolor;
474			size += boxcount * 12;
475			if (cfgfile && size == 0
476			&& (state != -1 \|\| fgcolor != -1 \|\| bgcolor != -1))
477			size = -1;
478			pic[12] = size;
479			pic[13] = size >> 8;
480			pic[14] = size >> 16;
481			pic[15] = size >> 24;
482			pic[16] = tx;
483			pic[17] = tx >> 8;
484			pic[18] = ty;
485			pic[19] = ty >> 8;
486			pic[20] = tw;
487			pic[21] = tw >> 8;
488			pic[22] = th;
489			pic[23] = th >> 8;
490			pic[24] = boxcount;
491			pic[25] = boxcount >> 8;
492			pic[28] = silentl;
493			pic[29] = silentl >> 8;
494			pic[30] = silentl >> 16;
495			pic[31] = silentl >> 24;
496			pic[32] = sboxcount;
497			pic[33] = sboxcount >> 8;
498			pic[34] = percent;
499			pic[35] = percent >> 8;
500			pic[36] = overpaintok;
501			pic[37] = 0; /* numpalette */
502			if (l > 0)
503			memmove(pic + 38 + boxcount * 12,
504			pic + 47 + boxcount * 12, l);
505			if (boxcount)
506			memmove(pic + 38, boxes, boxcount * 12);
507			l += 38 + boxcount * 12;
508			}
509
510			if (filterflag)
511			fd = 1;
512			else if ((fd = open(PROCSPLASH, O_WRONLY)) == -1) {
513			perror(PROCSPLASH);
514			exit(1);
515			}
516			if (write(fd, pic, l) != l) {
517			perror("write");
518			exit(1);
519			}
520			if (!filterflag)
521			close(fd);
522			free(pic);
523			}
524
525			int main(int argc, char *argv[])
526			{
527			int procsplash, c;
528			int setflag = 0;
529			int errflag = 0;
530			int filterflag = 0;
531			int verbose_only = 0;
532			unsigned char *readbuffer;
533
534			while ((c = getopt(argc, argv, "fsu:n")) != EOF) {
535			switch (c) {
536			case 's':
537			setflag = 1;
538			break;
539			case 'f':
540			filterflag = 1;
541			break;
542			case 'u':
543			unit = atoi(optarg);
544			break;
545			case 'n':
546			verbose_only = 1;
547			break;
548			case '?':
549			errflag = 1;
550			break;
551			}
552			}
553
554			if (errflag
555			\|\| (argc != optind + 1 && (argc != optind \|\| !setflag))) {
556			printf("Usage: %s -s [-u unit] -n [cfgfile]\n", argv[0]);
557			return 0;
558			}
559
560			readbuffer = malloc(BUFSIZE);
561
562			if (!readbuffer) {
563			DEBUG("splash: Not enough memory.\n");
564			return -ENOMEM;
565			}
566
567			if (!setflag \|\| !filterflag) {
568			procsplash = open(PROCSPLASH, O_RDONLY);
569			if (procsplash < 0) {
570			if (setflag) {
571			perror(PROCSPLASH);
572			exit(1);
573			}
574			DEBUG("splash: File %s not available.\n",
575			PROCSPLASH);
576			return 0;
577			}
578
579			if (read(procsplash, readbuffer, BUFSIZE) < 0) {
580			if (setflag)
581			perror("read");
582			DEBUG("splash: Read error in file %s.\n",
583			PROCSPLASH);
584			return -EBUSY;
585			}
586			close(procsplash);
587			}
588			if (setflag) {
589			if (!filterflag
590			&& !strncmp(readbuffer, "Splash screen v0", 16)) {
591			fprintf(stderr,
592			"Your kernel support for the bootsplash is too old. Get the new version from http://www.bootsplash.org/\n");
593			exit(1);
594			}
595			setsplash(argc > optind ? argv[optind] : 0, filterflag,
596			verbose_only);
597			exit(0);
598			}
599
600			return 0;
601			}