int
main (void)
{
int fd;
fd = net_bind ();
if (fd < 0)
{
perror ("bind");
return 1;
}
graphics_initialise ();
graphics_mode(1);
while (netphysics_read_packet (fd))
{
SDL_Event event;
if (SDL_PollEvent(&event) &&
(event.type == SDL_QUIT || (event.type == SDL_KEYDOWN &&
event.key.keysym.sym == SDLK_ESCAPE)))
return 0;
graphics_render (0, 0);
}
return 0;
}
static void ng_special_out (SIGNED_QUAD len, unsigned char **start, unsigned char *end, SIGNED_QUAD h, SIGNED_QUAD v)
{
uint8_t *buffer;
if (*start <= end - len)
{
buffer = NEW(len+1, uint8_t);
memcpy(buffer, *start, len);
buffer[len] = '\0';
{
uint8_t *p = buffer;
while (p < buffer + len && *p == ' ')
p++;
/*
* Warning message from virtual font.
*/
if (!memcmp((char *)p, "Warning:", 8))
{
if (verbose)
WARN("VF:%s", p+8);
}
else
{
double spc_h = 0.000015202 * h;
double spc_v = 0.000015202 * v;
graphics_mode();
spc_exec_special(buffer, len, spc_h, spc_v, 1.0);
}
}
RELEASE(buffer);
}
else
{
ERROR ("Premature end of DVI byte stream in VF font.");
}
*start += len;
}
/*
* mask == 0 means stroking color, mask == 0x20 nonstroking color
*
* force == 1 means that operators will be generated even if
* the color is the same as the current graphics state color
*/
void
pdf_dev_set_color (const pdf_color *color, char mask, int force)
{
int len;
pdf_gstate *gs = m_stack_top(&gs_stack);
pdf_color *current = mask ? &gs->fillcolor : &gs->strokecolor;
ASSERT(pdf_color_is_valid(color));
if (!(pdf_dev_get_param(PDF_DEV_PARAM_COLORMODE) &&
(force || pdf_color_compare(color, current))))
/* If "color" is already the current color, then do nothing
* unless a color operator is forced
*/
return;
graphics_mode();
len = pdf_color_to_string(color, fmt_buf);
fmt_buf[len++] = ' ';
switch (pdf_color_type(color)) {
case PDF_COLORSPACE_TYPE_RGB:
fmt_buf[len++] = 'R' | mask;
fmt_buf[len++] = 'G' | mask;
break;
case PDF_COLORSPACE_TYPE_CMYK:
fmt_buf[len++] = 'K' | mask;
break;
case PDF_COLORSPACE_TYPE_GRAY:
fmt_buf[len++] = 'G' | mask;
break;
default: /* already verified the given color */
break;
}
pdf_doc_add_page_content(fmt_buf, len); /* op: RG K G rg k g */
pdf_color_copycolor(current, color);
}
EFI_STATUS efi_main(EFI_HANDLE image, EFI_SYSTEM_TABLE *sys_table) {
EFI_LOADED_IMAGE *loaded_image;
CHAR8 *b;
UINTN size;
BOOLEAN secure = FALSE;
CHAR8 *sections[] = {
(UINT8 *)".cmdline",
(UINT8 *)".linux",
(UINT8 *)".initrd",
(UINT8 *)".splash",
NULL
};
UINTN addrs[ELEMENTSOF(sections)-1] = {};
UINTN offs[ELEMENTSOF(sections)-1] = {};
UINTN szs[ELEMENTSOF(sections)-1] = {};
CHAR8 *cmdline = NULL;
UINTN cmdline_len;
CHAR16 uuid[37];
EFI_STATUS err;
InitializeLib(image, sys_table);
err = uefi_call_wrapper(BS->OpenProtocol, 6, image, &LoadedImageProtocol, (VOID **)&loaded_image,
image, NULL, EFI_OPEN_PROTOCOL_GET_PROTOCOL);
if (EFI_ERROR(err)) {
Print(L"Error getting a LoadedImageProtocol handle: %r ", err);
uefi_call_wrapper(BS->Stall, 1, 3 * 1000 * 1000);
return err;
}
if (efivar_get_raw(&global_guid, L"SecureBoot", &b, &size) == EFI_SUCCESS) {
if (*b > 0)
secure = TRUE;
FreePool(b);
}
err = pe_memory_locate_sections(loaded_image->ImageBase, sections, addrs, offs, szs);
if (EFI_ERROR(err)) {
Print(L"Unable to locate embedded .linux section: %r ", err);
uefi_call_wrapper(BS->Stall, 1, 3 * 1000 * 1000);
return err;
}
if (szs[0] > 0)
cmdline = (CHAR8 *)(loaded_image->ImageBase + addrs[0]);
cmdline_len = szs[0];
/* if we are not in secure boot mode, accept a custom command line and replace the built-in one */
if (!secure && loaded_image->LoadOptionsSize > 0 && *(CHAR16 *)loaded_image->LoadOptions != 0) {
CHAR16 *options;
CHAR8 *line;
UINTN i;
options = (CHAR16 *)loaded_image->LoadOptions;
cmdline_len = (loaded_image->LoadOptionsSize / sizeof(CHAR16)) * sizeof(CHAR8);
line = AllocatePool(cmdline_len);
for (i = 0; i < cmdline_len; i++)
line[i] = options[i];
cmdline = line;
#if ENABLE_TPM
/* Try to log any options to the TPM, especially manually edited options */
err = tpm_log_event(SD_TPM_PCR,
(EFI_PHYSICAL_ADDRESS) loaded_image->LoadOptions,
loaded_image->LoadOptionsSize, loaded_image->LoadOptions);
if (EFI_ERROR(err)) {
Print(L"Unable to add image options measurement: %r", err);
uefi_call_wrapper(BS->Stall, 1, 200 * 1000);
}
#endif
}
/* export the device path this image is started from */
if (disk_get_part_uuid(loaded_image->DeviceHandle, uuid) == EFI_SUCCESS)
efivar_set(L"LoaderDevicePartUUID", uuid, FALSE);
if (szs[3] > 0)
graphics_splash((UINT8 *)((UINTN)loaded_image->ImageBase + addrs[3]), szs[3], NULL);
err = linux_exec(image, cmdline, cmdline_len,
(UINTN)loaded_image->ImageBase + addrs[1],
(UINTN)loaded_image->ImageBase + addrs[2], szs[2], secure);
graphics_mode(FALSE);
Print(L"Execution of embedded linux image failed: %r\n", err);
uefi_call_wrapper(BS->Stall, 1, 3 * 1000 * 1000);
return err;
}
/* FIXME */
static int
pdf_dev__flushpath (pdf_path *pa,
char opchr,
int rule,
int ignore_rule)
{
pa_elem *pe, *pe1;
char *b = fmt_buf;
long b_len = FORMAT_BUFF_LEN;
pdf_rect r; /* FIXME */
pdf_coord *pt;
int n_pts, n_seg;
int len = 0;
int isclip = 0;
int isrect, i, j;
ASSERT(pa && PT_OP_VALID(opchr));
isclip = (opchr == 'W') ? 1 : 0;
if (PA_LENGTH(pa) <= 0 && path_added == 0)
return 0;
path_added = 0;
graphics_mode();
isrect = pdf_path__isarect(pa, ignore_rule);
if (isrect) {
pe = &(pa->path[0]);
pe1 = &(pa->path[2]);
r.llx = pe->p[0].x;
r.lly = pe->p[0].y;
r.urx = pe1->p[0].x - pe->p[0].x; /* width... */
r.ury = pe1->p[0].y - pe->p[0].y; /* height... */
b[len++] = ' ';
len += pdf_sprint_rect(b + len, &r);
b[len++] = ' ';
b[len++] = 'r';
b[len++] = 'e';
pdf_doc_add_page_content(b, len); /* op: re */
len = 0;
} else {
n_seg = PA_LENGTH(pa);
for (i = 0, len = 0, pe = &pa->path[0];
i < n_seg; pe++, i++) {
n_pts = PE_N_PTS(pe);
for (j = 0, pt = &pe->p[0];
j < n_pts; j++, pt++) {
b[len++] = ' ';
len += pdf_sprint_coord(b + len, pt);
}
b[len++] = ' ';
b[len++] = PE_OPCHR(pe);
if (len + 128 > b_len) {
pdf_doc_add_page_content(b, len); /* op: m l c v y h */
len = 0;
}
}
if (len > 0) {
pdf_doc_add_page_content(b, len); /* op: m l c v y h */
len = 0;
}
}
b[len++] = ' ';
b[len++] = opchr;
if (rule == PDF_FILL_RULE_EVENODD)
b[len++] = '*';
if (isclip) {
b[len++] = ' '; b[len++] = 'n';
}
pdf_doc_add_page_content(b, len); /* op: f F s S b B W f* F* s* S* b* B* W* */
return 0;
}
/* rectfill, rectstroke, rectclip, recteoclip
*
* Draw isolated rectangle without actually doing
* gsave/grestore operation.
*
* TODO:
* linestyle, fill-opacity, stroke-opacity,....
* As this routine draw a single graphics object
* each time, there should be options for specifying
* various drawing styles, which might inherite
* current graphcs state parameter.
*/
static int
pdf_dev__rectshape (const pdf_rect *r,
const pdf_tmatrix *M,
char opchr
)
{
char *buf = fmt_buf;
int len = 0;
int isclip = 0;
pdf_coord p;
double wd, ht;
ASSERT(r && PT_OP_VALID(opchr));
isclip = (opchr == 'W' || opchr == ' ') ? 1 : 0;
/* disallow matrix for clipping.
* q ... clip Q does nothing and
* n M cm ... clip n alter CTM.
*/
if (M && (isclip ||
!INVERTIBLE_MATRIX(M)))
return -1;
graphics_mode();
buf[len++] = ' ';
if (!isclip) {
buf[len++] = 'q';
if (M) {
buf[len++] = ' ';
len += pdf_sprint_matrix(buf + len, M);
buf[len++] = ' ';
buf[len++] = 'c'; buf[len++] = 'm';
}
buf[len++] = ' ';
}
buf[len++] = 'n';
p.x = r->llx; p.y = r->lly;
wd = r->urx - r->llx;
ht = r->ury - r->lly;
buf[len++] = ' ';
len += pdf_sprint_coord (buf + len, &p);
buf[len++] = ' ';
len += pdf_sprint_length(buf + len, wd);
buf[len++] = ' ';
len += pdf_sprint_length(buf + len, ht);
buf[len++] = ' ';
buf[len++] = 'r'; buf[len++] = 'e';
if (opchr != ' ') {
buf[len++] = ' ';
buf[len++] = opchr;
buf[len++] = ' ';
buf[len++] = isclip ? 'n' : 'Q';
}
pdf_doc_add_page_content(buf, len); /* op: q cm n re Q */
return 0;
}
int
main (int argc, char **argv)
{
net_addr remote;
int serial;
int net;
graphics_initialise ();
graphics_mode (0);
serial = serial_open ();
net = net_open ();
if (argc != 1)
{
if (argc != 2)
{
fprintf (stderr, "only 1 or 0 args\n");
return 1;
}
if (strcmp (argv[1], "--final"))
{
fprintf (stderr, "unrecognised option\n");
return 1;
}
}
else
randomised = true;
printf ("randomised: %d\n", randomised);
while (serial_ready (serial))
serial_discard (serial);
net_addr_set (&remote, "10.0.0.2");
while (true)
{
bool ended;
/* wait for user */
reset_the_physics (true);
publish_the_physics (serial, net, &remote);
graphics_render (0, 0);
while (!serial_ready (serial))
check_sdl ();
reset_the_physics (false);
ended = false;
while (!ended)
{
serial_read (serial);
poll (NULL, 0, 10);
ended = physics_update ();
publish_the_physics (serial, net, &remote);
check_sdl ();
graphics_render (0, 0);
}
while (check_sdl () != ' ')
poll (NULL, 0, 10);
while (serial_ready (serial))
serial_read (serial);
}
}
