static int myprintf(const char *format, ...){
va_list ap;
const char *s;
const char *p;
union {
int intv;
char *charv;
unsigned int uintv;
uint64_t uint64v;
} param;
va_start(ap, format);
p=s=format;
while(*p != 0){
while(*p && *p != '%')
++p;
if(p!=s){
write(1, s, p-s);
s=p;
}
if(*p == '%'){
switch(p[1]){
case 's':
param.charv = va_arg(ap, char *);
write(1, param.charv, strlen(param.charv));
break;
case 'd':
param.intv = va_arg(ap, int);
write_dec(param.intv);
break;
case 'x':
param.uintv = va_arg(ap, unsigned int);
write_hex(param.uintv);
break;
case 'p':
#if defined(ARCH_X86) || defined(ARCH_ARM)
param.uintv = va_arg(ap, unsigned int);
write_hex(param.uintv);
break;
#else
param.uint64v = va_arg(ap, uint64_t);
write_hex64(param.uint64v);
break;
#endif
case '\0':
goto end;
}
p += 2;
s=p;
}
}
end:
va_end(ap);
return 0;
}
static int copy_data_hex(char *data, int off, const char *str, int width)
{
char *tmp, *s = NULL, *p = data;
int ret;
tmp = strdup(str);
if (tmp == NULL)
return -ENOMEM;
p += off;
s = strtok(tmp, ",");
while (s != NULL) {
ret = write_hex(p, s, width);
if (ret < 0) {
free(tmp);
return ret;
}
s = strtok(NULL, ",");
p += width;
}
free(tmp);
return 0;
}
static void write_fmt(const char* fmt, va_list vp)
{
double vargflt = 0 ;
int vargint = 0 ;
char* vargpch = NULL ;
char vargch = 0 ;
const char* pfmt = NULL ;
pfmt = fmt ;
while(*pfmt)
{
if(*pfmt == '%')
{
switch(*(++pfmt))
{
case 'c' :
vargch = va_arg(vp, int) ;
write_ch(vargch) ;
break ;
case 'd' :
case 'i' :
vargint = va_arg(vp, int) ;
write_dec(vargint) ;
break ;
case 'f':
vargflt = va_arg(vp, double) ;
write_flt(vargflt) ;
break ;
case 's' :
vargpch = va_arg(vp, char*);
write_str(vargpch) ;
break ;
case 'b':
case 'B':
vargint = va_arg(vp, int);
write_bin(vargint) ;
break ;
case 'x' :
case 'X':
vargint = va_arg(vp, int) ;
write_hex(vargint) ;
break ;
case '%' :
write_ch('%') ;
break ;
default :
break ;
}
pfmt++ ;
}
else
{
write_ch(*pfmt++) ;
}
}
Buffer<Allocator>& Buffer<Allocator>::write_hex(double n) {
union {
double d;
s8 l;
} u;
u.d = n;
return write_hex(u.l);
}
Buffer<Allocator>& Buffer<Allocator>::write_hex(float n) {
union {
float f;
s4 i;
} u;
u.f = n;
return write_hex(u.i);
}
static void
usbdevfs_reapurb_write(const ioctl_tree * node, FILE * f)
{
const struct usbdevfs_urb *urb = node->data;
assert(node->data != NULL);
fprintf(f, "%u %u %i %u %i %i %i ", (unsigned)urb->type,
(unsigned)urb->endpoint, urb->status, (unsigned)urb->flags,
urb->buffer_length, urb->actual_length, urb->error_count);
write_hex(f, urb->buffer, urb->endpoint & 0x80 ? urb->actual_length : urb->buffer_length);
/* for debugging test cases with ASCII contents */
/*fwrite (urb->buffer, urb->endpoint & 0x80 ? urb->actual_length : urb->buffer_length, 1, f); */
}
static void get_utf8(int i, FILE *fp)
{
long u = 0, j;
int i2 = EOF, i3 = EOF, i4 = EOF;
switch (UTF8length(i)) {
case 2:
i2 = getcUTF8(fp); if (i2 == EOF) break;
u = UTF8BtoUCS(i, i2);
break;
case 3:
i2 = getcUTF8(fp); if (i2 == EOF) break;
i3 = getcUTF8(fp); if (i3 == EOF) break;
u = UTF8CtoUCS(i, i2, i3);
if (u == U_BOM) return; /* just ignore */
if (u == U_VOICED && combin_voiced_sound(false)) return;
if (u == U_SEMI_VOICED && combin_voiced_sound(true)) return;
break;
case 4:
i2 = getcUTF8(fp); if (i2 == EOF) break;
i3 = getcUTF8(fp); if (i3 == EOF) break;
i4 = getcUTF8(fp); if (i4 == EOF) break;
u = UTF8DtoUCS(i, i2, i3, i4);
break;
default:
u = U_REPLACEMENT_CHARACTER;
break;
}
j = toBUFF(fromUCS(u));
if (j == 0) { /* can't represent (typically umlaut o in EUC) */
write_hex(i);
if (i2 != EOF) write_hex(i2);
if (i3 != EOF) write_hex(i3);
if (i4 != EOF) write_hex(i4);
} else {
write_multibyte(j);
}
}
static void write_packet(struct dbg_context* dbg, const char* data)
{
byte checksum;
size_t len, i;
write_data_raw(dbg, (byte*)"$", 1);
len = strlen(data);
for (i = 0, checksum = 0; i < len; ++i) {
checksum += data[i];
}
write_data_raw(dbg, (byte*)data, len);
write_data_raw(dbg, (byte*)"#", 1);
write_hex(dbg, checksum);
}
int lame_vsprintf(char *str, const char *format, va_list ap)
{
bool in_control_code = false;
char *current = str;
for(; *format; format++) {
if(!in_control_code) {
if(*format == '%')
in_control_code = true;
else
*current++ = *format;
} else {
switch(*format) {
case 'x':
case 'X': {
unsigned val = va_arg(ap, unsigned);
current = write_hex(current, val);
break;
}
case 'd': {
unsigned val = va_arg(ap, unsigned);
current = write_dec(current, val);
break;
}
case 'p': {
void *val = va_arg(ap, void *);
current = write_ptr(current, val);
break;
}
case 's': {
const char *val = va_arg(ap, const char *);
current = write_str(current, val);
break;
}
default:
*current++ = *format;
break;
}
in_control_code = false;
}
}
*current++ = '\0';
return current - str;
}
static void write_hex(int hex)
{
if(hex == 0)
{
write_str("0x");
return ;
}
write_hex(hex/16);
if(hex < 10)
{
write_ch( (char)(hex%16 + '0')) ;
}else
{
write_ch( (char)(hex%16-10 +'a')) ;
}
}
int socket_write(int socket, char* buf, int* len, bool isServer) {
int written = write(socket, buf, *len);
if (written <= 0) {
return written;
}
fprintf(logfile, "%s (%s:%d) [%d]\n", (isServer ? "S>C" : "C>S"), remoteaddr, remoteport, written);
if (verbose) {
fprintf(stdout, "%s (%s:%d) [%d]\n", (isServer ? "S>C" : "C>S"), remoteaddr, remoteport, written);
}
write_hex(buf, written);
fflush(logfile);
if (written != *len) {
memmove(buf, buf+written, (*len)-written);
}
*len -= written;
return written;
}
/*
* We switch the user's privilege to read ~/.gfarm_shared_key.
*
* NOTE: reading this file with root privilege may not work,
* if home directory is NFS mounted and root access for
* the home directory partition is not permitted.
*
* Do not leave the user privilege switched here, even in the switch_to case,
* because it is necessary to switch back to the original user privilege when
* gfarm_auth_sharedsecret fails.
*/
gfarm_error_t
gfarm_auth_shared_key_get(unsigned int *expirep, char *shared_key,
char *home, struct passwd *pwd, int create, int period)
{
gfarm_error_t e;
FILE *fp;
static char keyfile_basename[] = "/" GFARM_AUTH_SHARED_KEY_BASENAME;
char *keyfilename;
unsigned int expire;
static pthread_mutex_t privilege_mutex = PTHREAD_MUTEX_INITIALIZER;
uid_t o_uid;
gid_t o_gid;
#ifdef __GNUC__ /* workaround gcc warning: might be used uninitialized */
o_uid = o_gid = 0;
#endif
GFARM_MALLOC_ARRAY(keyfilename,
strlen(home) + sizeof(keyfile_basename));
if (keyfilename == NULL)
return (GFARM_ERR_NO_MEMORY);
strcpy(keyfilename, home);
strcat(keyfilename, keyfile_basename);
if (pwd != NULL) {
pthread_mutex_lock(&privilege_mutex);
o_gid = getegid();
o_uid = geteuid();
seteuid(0); /* recover root privilege */
initgroups(pwd->pw_name, pwd->pw_gid);
setegid(pwd->pw_gid);
seteuid(pwd->pw_uid);
}
if ((fp = fopen(keyfilename, "r+")) != NULL) {
if (skip_space(fp) || read_hex(fp, &expire, sizeof(expire))) {
fclose(fp);
free(keyfilename);
e = GFARM_ERRMSG_SHAREDSECRET_INVALID_EXPIRE_FIELD;
goto finish;
}
expire = ntohl(expire);
if (skip_space(fp) ||
read_hex(fp, shared_key, GFARM_AUTH_SHARED_KEY_LEN)) {
fclose(fp);
free(keyfilename);
e = GFARM_ERRMSG_SHAREDSECRET_INVALID_KEY_FIELD;
goto finish;
}
}
if (fp == NULL) {
if (create == GFARM_AUTH_SHARED_KEY_GET) {
free(keyfilename);
e = GFARM_ERRMSG_SHAREDSECRET_KEY_FILE_NOT_EXIST;
goto finish;
}
fp = fopen(keyfilename, "w+");
if (fp == NULL) {
e = gfarm_errno_to_error(errno);
free(keyfilename);
goto finish;
}
if (chmod(keyfilename, 0600) == -1) {
e = gfarm_errno_to_error(errno);
fclose(fp);
free(keyfilename);
goto finish;
}
expire = 0; /* force to regenerate key */
}
if (create == GFARM_AUTH_SHARED_KEY_CREATE_FORCE ||
time(NULL) >= expire) {
if (create == GFARM_AUTH_SHARED_KEY_GET) {
fclose(fp);
free(keyfilename);
e = GFARM_ERR_EXPIRED;
goto finish;
}
if (fseek(fp, 0L, SEEK_SET) == -1) {
e = gfarm_errno_to_error(errno);
fclose(fp);
free(keyfilename);
goto finish;
}
gfarm_auth_random(shared_key, GFARM_AUTH_SHARED_KEY_LEN);
if (period <= 0)
period = GFARM_AUTH_EXPIRE_DEFAULT;
expire = time(NULL) + period;
expire = htonl(expire);
write_hex(fp, &expire, sizeof(expire));
expire = ntohl(expire);
fputc(' ', fp);
write_hex(fp, shared_key, GFARM_AUTH_SHARED_KEY_LEN);
fputc('\n', fp);
}
fclose(fp);
free(keyfilename);
*expirep = expire;
e = GFARM_ERR_NO_ERROR;
finish:
if (pwd != NULL) {
seteuid(0); /* recover root privilege */
setgroups(1, &o_gid); /* abandon group privileges */
setegid(o_gid);
seteuid(o_uid); /* suppress root privilege, if possible */
pthread_mutex_unlock(&privilege_mutex);
}
return (e);
}
static void
ioctl_simplestruct_write(const ioctl_tree * node, FILE * f)
{
assert(node->data != NULL);
write_hex(f, node->data, NSIZE(node));
}
int main(int argc, char *argv[])
{
struct _memory memory;
char *filename=NULL;
char *uart="/dev/ttyUSB0";
int prog_type=PROG_UNDEF;
int command=COMMAND_UNDEF;
int param1=0,param2=0;
int i;
printf("\nnaken_prog - by Michael Kohn\n");
printf(" Web: http://www.mikekohn.net/\n");
printf(" Email: [email protected]\n\n");
printf("Version: "VERSION"\n\n");
if (argc<2)
{
printf("Usage: naken_util [options]\n");
printf(" CPU options:\n");
printf(" -lpc\n");
printf(" Command:\n");
printf(" -info\n");
printf(" -write <outfile>\n");
printf(" -read <address> <count> <infile>\n");
printf(" -execute <address>\n");
printf("\n");
exit(0);
}
memset(&memory, 0, sizeof(memory));
for (i=1; i<argc; i++)
{
if (strcmp(argv[i], "-lpc")==0)
{
prog_type=PROG_LPC;
}
else
if (strcmp(argv[i], "-info")==0)
{
command=COMMAND_INFO;
}
else
if (strcmp(argv[i], "-read")==0)
{
command=COMMAND_READ;
if (i+2>=argc)
{
printf("Error: -read command takes 2 arguments\n");
exit(1);
}
param1=atoi(argv[++i]);
param2=atoi(argv[++i]);
}
else
if (strcmp(argv[i], "-write")==0)
{
command=COMMAND_WRITE;
}
else
if (strcmp(argv[i], "-run")==0)
{
command=COMMAND_RUN;
param1=atoi(argv[++i]);
}
else
{
filename=argv[i];
}
}
if (prog_type==PROG_UNDEF)
{
printf("Error: No chip type selected.\n");
exit(0);
}
if (command==COMMAND_INFO)
{
if (prog_type==PROG_LPC)
{
lpc_info(uart);
}
}
else
if (command==COMMAND_READ)
{
if (filename==NULL)
{
printf("No output filename. Exiting...\n");
exit(1);
}
memory_init(&memory, 0xffffffff, 1);
lpc_memory_read(uart, &memory, param1, param2);
// FIXME - make filename selectable
FILE *out=fopen(filename, "wb");
write_hex(&memory, out);
fclose(out);
memory_free(&memory);
}
else
if (command==COMMAND_WRITE)
{
unsigned char cpu_type;
if (filename==NULL)
{
printf("No hexfile loaded. Exiting...\n");
exit(1);
}
memory_init(&memory, 0xffffffff, 1);
if (read_elf(filename, &memory, &cpu_type, NULL)>=0)
{
printf("Loaded ELF %s from 0x%04x to 0x%04x\n", filename, memory.low_address, memory.high_address);
}
else
if (read_hex(filename, &memory)>=0)
{
printf("Loaded hexfile %s from 0x%04x to 0x%04x\n", filename, memory.low_address, memory.high_address);
}
else
{
printf("Could not load hexfile\n");
memory_free(&memory);
exit(1);
}
lpc_memory_write(uart, &memory);
memory_free(&memory);
}
else
if (command==COMMAND_RUN)
{
if (prog_type==PROG_LPC)
{
lpc_run(uart, param1);
}
}
return 0;
}
char *
gfarm_auth_shared_key_get(unsigned int *expirep, char *shared_key,
char *home, int create, int period)
{
FILE *fp;
static char keyfile_basename[] = "/" GFARM_AUTH_SHARED_KEY_BASENAME;
char *keyfilename;
unsigned int expire;
keyfilename = malloc(strlen(home) + sizeof(keyfile_basename));
if (keyfilename == NULL)
return (GFARM_ERR_NO_MEMORY);
strcpy(keyfilename, home);
strcat(keyfilename, keyfile_basename);
if ((fp = fopen(keyfilename, "r+")) != NULL) {
if (skip_space(fp) || read_hex(fp, &expire, sizeof(expire))) {
fclose(fp);
free(keyfilename);
return ("~/" GFARM_AUTH_SHARED_KEY_BASENAME
": invalid expire field");
}
expire = ntohl(expire);
if (skip_space(fp) ||
read_hex(fp, shared_key, GFARM_AUTH_SHARED_KEY_LEN)) {
fclose(fp);
free(keyfilename);
return ("~/" GFARM_AUTH_SHARED_KEY_BASENAME
": invalid key field");
}
}
if (fp == NULL) {
if (create == GFARM_AUTH_SHARED_KEY_GET) {
free(keyfilename);
return ("~/" GFARM_AUTH_SHARED_KEY_BASENAME
": not exist");
}
fp = fopen(keyfilename, "w+");
if (fp == NULL) {
free(keyfilename);
return (gfarm_errno_to_error(errno));
}
if (chmod(keyfilename, 0600) == -1) {
fclose(fp);
free(keyfilename);
return (gfarm_errno_to_error(errno));
}
expire = 0; /* force to regenerate key */
}
if (create == GFARM_AUTH_SHARED_KEY_CREATE_FORCE ||
time(NULL) >= expire) {
if (create == GFARM_AUTH_SHARED_KEY_GET) {
fclose(fp);
free(keyfilename);
return (GFARM_ERR_EXPIRED);
}
if (fseek(fp, 0L, SEEK_SET) == -1) {
fclose(fp);
free(keyfilename);
return (gfarm_errno_to_error(errno));
}
gfarm_auth_random(shared_key, GFARM_AUTH_SHARED_KEY_LEN);
if (period <= 0)
period = GFARM_AUTH_EXPIRE_DEFAULT;
expire = time(NULL) + period;
expire = htonl(expire);
write_hex(fp, &expire, sizeof(expire));
expire = ntohl(expire);
fputc(' ', fp);
write_hex(fp, shared_key, GFARM_AUTH_SHARED_KEY_LEN);
fputc('\n', fp);
}
fclose(fp);
free(keyfilename);
*expirep = expire;
return (NULL);
}
static void
ioctl_varlenstruct_write(const ioctl_tree * node, FILE * f)
{
assert(node->data != NULL);
write_hex(f, node->data, node->type->get_data_size(node->id, node->data));
}
static int
usbdevfs_reapurb_execute(const ioctl_tree * node, unsigned long id, void *arg, int *ret)
{
/* set in SUBMIT, cleared in REAP */
static const ioctl_tree *submit_node = NULL;
static struct usbdevfs_urb *submit_urb = NULL;
if (id == USBDEVFS_SUBMITURB) {
const struct usbdevfs_urb *n_urb = node->data;
struct usbdevfs_urb *a_urb = arg;
assert(submit_node == NULL);
if (n_urb->type != a_urb->type || n_urb->endpoint != a_urb->endpoint ||
n_urb->flags != a_urb->flags || n_urb->buffer_length != a_urb->buffer_length)
return 0;
DBG(DBG_IOCTL_TREE, " usbdevfs_reapurb_execute: handling SUBMITURB, metadata match\n");
/* for an output URB we also require the buffer contents to match; for
* an input URB it can be uninitialized */
if ((n_urb->endpoint & 0x80) == 0 && memcmp(n_urb->buffer, a_urb->buffer, n_urb->buffer_length) != 0) {
DBG(DBG_IOCTL_TREE, " usbdevfs_reapurb_execute: handling SUBMITURB, buffer mismatch, rejecting\n");
return 0;
}
DBG(DBG_IOCTL_TREE, " usbdevfs_reapurb_execute: handling SUBMITURB, buffer match, remembering\n");
/* remember the node for the next REAP */
submit_node = node;
submit_urb = a_urb;
*ret = 0;
return 1;
}
if (id == node->type->id) {
struct usbdevfs_urb *orig_node_urb;
if (submit_node == NULL) {
DBG(DBG_IOCTL_TREE, " usbdevfs_reapurb_execute: handling %s, but no submit node -> EAGAIN\n", node->type->name);
*ret = -1;
errno = EAGAIN;
return 2;
}
orig_node_urb = submit_node->data;
submit_urb->actual_length = orig_node_urb->actual_length;
submit_urb->error_count = orig_node_urb->error_count;
/* for an input EP we need to copy the buffer data */
if (orig_node_urb->endpoint & 0x80) {
memcpy(submit_urb->buffer, orig_node_urb->buffer, orig_node_urb->actual_length);
}
submit_urb->status = orig_node_urb->status;
*((struct usbdevfs_urb **)arg) = submit_urb;
DBG(DBG_IOCTL_TREE, " usbdevfs_reapurb_execute: handling %s %u %u %i %u %i %i %i ",
node->type->name, (unsigned)submit_urb->type,
(unsigned)submit_urb->endpoint, submit_urb->status,
(unsigned)submit_urb->flags, submit_urb->buffer_length, submit_urb->actual_length, submit_urb->error_count);
if (debug_categories & DBG_IOCTL_TREE)
write_hex(stderr, submit_urb->buffer, submit_urb->endpoint & 0x80 ?
submit_urb->actual_length : submit_urb->buffer_length);
submit_urb = NULL;
submit_node = NULL;
*ret = 0;
return 2;
}
return 0;
}
static char *write_ptr(char *str, void *val)
{
return write_hex(str, (uintptr_t)val);
}
int main(int argc, char *argv[])
{
FILE *out;
FILE *dbg = NULL;
//FILE *list = NULL;
int i;
int format = FORMAT_HEX;
int create_list = 0;
char *infile = NULL, *outfile = NULL;
struct _asm_context asm_context;
int error_flag=0;
puts(credits);
if (argc < 2)
{
printf("Usage: naken_asm [options] <infile>\n"
" -o <outfile>\n"
" -h [output hex file]\n"
#ifndef DISABLE_ELF
" -e [output elf file]\n"
#endif
" -b [output binary file]\n"
" -s [output srec file]\n"
" -l [create .lst listing file]\n"
" -I [add to include path]\n"
" -q Quiet (only output errors)\n"
"\n");
exit(0);
}
memset(&asm_context, 0, sizeof(asm_context));
for (i = 1; i < argc; i++)
{
if (strcmp(argv[i], "-o") == 0)
{
outfile = argv[++i];
}
else
if (strcmp(argv[i], "-h") == 0)
{
format = FORMAT_HEX;
}
else
if (strcmp(argv[i], "-b") == 0)
{
format = FORMAT_BIN;
}
else
if (strcmp(argv[i], "-s") == 0)
{
format = FORMAT_SREC;
}
#ifndef DISABLE_ELF
else
if (strcmp(argv[i], "-e") == 0)
{
format = FORMAT_ELF;
}
#endif
#if 0
else
if (strcmp(argv[i], "-d") == 0)
{
asm_context.debug_file = 1;
}
#endif
else
if (strcmp(argv[i], "-l") == 0)
{
create_list = 1;
}
else
if (strncmp(argv[i], "-I", 2) == 0)
{
char *s = argv[i];
if (s[2] == 0)
{
if (add_to_include_path(&asm_context, argv[++i]) != 0)
{
printf("Internal Error: Too many include paths\n");
exit(1);
}
}
else
{
if (add_to_include_path(&asm_context, s+2) != 0)
{
printf("Internal Error: Too many include paths\n");
exit(1);
}
}
}
else
if (strcmp(argv[i], "-q") == 0)
{
asm_context.quiet_output = 1;
}
else
{
if (infile != NULL)
{
printf("Error: Cannot use %s as input file since %s was already chosen.\n", argv[1], infile);
exit(1);
}
infile = argv[i];
}
}
if (infile == NULL)
{
printf("No input file specified.\n");
exit(1);
}
if (outfile == NULL)
{
switch(format)
{
case FORMAT_HEX: outfile = "out.hex"; break;
case FORMAT_BIN: outfile = "out.bin"; break;
case FORMAT_ELF: outfile = "out.elf"; break;
case FORMAT_SREC: outfile = "out.srec"; break;
default: outfile = "out.err"; break;
}
}
#ifdef INCLUDE_PATH
if (add_to_include_path(&asm_context, INCLUDE_PATH) != 0)
{
printf("Internal Error: Too many include paths\n");
exit(1);
}
#endif
if (tokens_open_file(&asm_context, infile) != 0)
{
printf("Couldn't open %s for reading.\n", infile);
exit(1);
}
out = fopen(outfile, "wb");
if (out == NULL)
{
printf("Couldn't open %s for writing.\n", outfile);
exit(1);
}
if (asm_context.quiet_output == 0)
{
printf(" Input file: %s\n", infile);
printf("Output file: %s\n", outfile);
}
#if 0
if (asm_context.debug_file == 1)
{
char filename[1024];
strcpy(filename, outfile);
new_extension(filename, "ndbg", 1024);
dbg = fopen(filename,"wb");
if (dbg == NULL)
{
printf("Couldn't open %s for writing.\n",filename);
exit(1);
}
printf(" Debug file: %s\n",filename);
fprintf(dbg, "%s\n", infile);
}
#endif
if (create_list == 1)
{
char filename[1024];
strcpy(filename, outfile);
new_extension(filename, "lst", 1024);
asm_context.list = fopen(filename, "wb");
if (asm_context.list == NULL)
{
printf("Couldn't open %s for writing.\n", filename);
exit(1);
}
if (asm_context.quiet_output == 0)
{
printf(" List file: %s\n", filename);
}
}
if (asm_context.quiet_output == 0)
{
printf("\nPass 1...\n");
}
symbols_init(&asm_context.symbols);
macros_init(&asm_context.macros);
asm_context.pass = 1;
assemble_init(&asm_context);
error_flag = assemble(&asm_context);
if (error_flag != 0)
{
printf("** Errors... bailing out\n");
unlink(outfile);
}
else
{
symbols_lock(&asm_context.symbols);
// macros_lock(&asm_context.defines_heap);
if (asm_context.quiet_output == 0) { printf("Pass 2...\n"); }
asm_context.pass = 2;
assemble_init(&asm_context);
error_flag = assemble(&asm_context);
if (format == FORMAT_HEX)
{
write_hex(&asm_context.memory, out);
}
else
if (format == FORMAT_BIN)
{
write_bin(&asm_context.memory, out);
}
else
if (format == FORMAT_SREC)
{
write_srec(&asm_context.memory, out);
}
#ifndef DISABLE_ELF
else
if (format == FORMAT_ELF)
{
write_elf(&asm_context.memory, out, &asm_context.symbols, asm_context.filename, asm_context.cpu_type);
}
#endif
if (dbg != NULL)
{
for (i = 0; i < asm_context.memory.size; i++)
{
int debug_line = memory_debug_line(&asm_context, i);
putc(debug_line >> 8, dbg);
putc(debug_line & 0xff, dbg);
}
fclose(dbg);
}
}
fclose(out);
if (create_list == 1)
{
int ch = 0;
char str[17];
int ptr = 0;
fprintf(asm_context.list, "data sections:");
for (i = asm_context.memory.low_address; i <= asm_context.memory.high_address; i++)
{
if (memory_debug_line(&asm_context, i) == -2)
{
if (ch == 0)
{
if (ptr != 0)
{
output_hex_text(asm_context.list, str, ptr);
}
fprintf(asm_context.list, "\n%04x:", i/asm_context.bytes_per_address);
ptr = 0;
}
unsigned char data = memory_read(&asm_context, i);
fprintf(asm_context.list, " %02x", data);
if (data >= ' ' && data <= 120)
{ str[ptr++] = data; }
else
{ str[ptr++] = '.'; }
ch++;
if (ch == 16) { ch = 0; }
}
else
{
output_hex_text(asm_context.list, str, ptr);
ch = 0;
ptr = 0;
}
}
output_hex_text(asm_context.list, str, ptr);
fprintf(asm_context.list, "\n\n");
assemble_print_info(&asm_context, asm_context.list);
}
assemble_print_info(&asm_context, stdout);
//symbols_free(&asm_context.symbols);
//macros_free(&asm_context.macros);
if (asm_context.list != NULL) { fclose(asm_context.list); }
fclose(asm_context.in);
if (error_flag != 0)
{
printf("*** Failed ***\n\n");
unlink(outfile);
}
//memory_free(&asm_context.memory);
assemble_free(&asm_context);
if (error_flag != 0) { return -1; }
return 0;
}
void _start(int arg1, int arg2, void *openfirmware)
{
int chosen;
of_init(openfirmware);
/* open the input and output handle */
chosen = of_finddevice("/chosen");
of_getprop(chosen, "stdin", &of_input_handle, sizeof(of_input_handle));
of_getprop(chosen, "stdout", &of_output_handle, sizeof(of_output_handle));
puts("this is a test\n");
init_serial();
restart:
puts("waiting for command\n");
{
int base_address;
int entry_point;
int length;
int command;
unsigned char *ptr;
void (*func)(int, int, void *);
serial_read_int32(&command);
if(command != 0x99) {
puts("bad command, restarting\n");
goto restart;
}
serial_read_int32(&base_address);
serial_read_int32(&length);
serial_read_int32(&entry_point);
puts("read base and length, claiming\n");
puts("base ");
write_hex(base_address);
puts("\nlength ");
write_hex(length);
puts("\nentry_point ");
write_hex(entry_point);
puts("\n");
ptr = (void *)base_address;
of_claim(base_address, length, 0);
puts("reading data\n");
serial_read(ptr, length);
puts("done reading data, calling function\n");
func = (void *)entry_point;
func(arg1, arg2, openfirmware);
}
of_exit();
}
int main(int argc, char *argv[])
{
FILE *out;
FILE *dbg=NULL;
FILE *list=NULL;
int i;
int format=FORMAT_HEX;
int create_list=0;
char *infile=NULL,*outfile=NULL;
struct _asm_context asm_context;
int error_flag=0;
printf("\nnaken430asm - by Michael Kohn\n");
printf(" Web: http://www.mikekohn.net/\n");
printf(" Email: [email protected]\n\n");
printf("Version: "VERSION"\n\n");
if (argc<2)
{
printf("Usage: naken430asm [options] <infile>\n");
printf(" -o <outfile>\n");
printf(" -h [output hex file]\n");
#ifndef DISABLE_ELF
printf(" -e [output elf file]\n");
#endif
printf(" -b [output binary file]\n");
printf(" -d [create .ndbg debug file]\n");
printf(" -l [create .lst listing file]\n");
printf(" -I [add to include path]\n");
printf("\n");
exit(0);
}
memset(&asm_context, 0, sizeof(asm_context));
for (i=1; i<argc; i++)
{
if (strcmp(argv[i], "-o")==0)
{
outfile=argv[++i];
}
else
if (strcmp(argv[i], "-h")==0)
{
format=FORMAT_HEX;
}
else
if (strcmp(argv[i], "-b")==0)
{
format=FORMAT_BIN;
}
#ifndef DISABLE_ELF
else
if (strcmp(argv[i], "-e")==0)
{
format=FORMAT_ELF;
}
#endif
else
if (strcmp(argv[i], "-d")==0)
{
asm_context.debug_file=1;
}
else
if (strcmp(argv[i], "-l")==0)
{
create_list=1;
}
else
if (strncmp(argv[i], "-I", 2)==0)
{
char *s=argv[i];
if (s[2]==0)
{
if (add_to_include_path(&asm_context, argv[++i])!=0)
{
printf("Internal Error: Too many include paths\n");
exit(1);
}
}
else
{
if (add_to_include_path(&asm_context, s+2)!=0)
{
printf("Internal Error: Too many include paths\n");
exit(1);
}
}
}
else
{
infile=argv[i];
}
}
if (infile==NULL)
{
printf("No input file specified.\n");
exit(1);
}
if (outfile==NULL)
{
if (format==FORMAT_HEX)
{
outfile="out.hex";
}
else
if (format==FORMAT_BIN)
{
outfile="out.bin";
}
#ifndef DISABLE_ELF
else
if (format==FORMAT_ELF)
{
outfile="out.elf";
}
#endif
}
#ifdef INCLUDE_PATH
if (add_to_include_path(&asm_context, INCLUDE_PATH)!=0)
{
printf("Internal Error: Too many include paths\n");
exit(1);
}
#endif
asm_context.in=fopen(infile,"rb");
if (asm_context.in==NULL)
{
printf("Couldn't open %s for reading.\n",infile);
exit(1);
}
asm_context.filename=infile;
out=fopen(outfile,"wb");
if (out==NULL)
{
printf("Couldn't open %s for writing.\n",outfile);
exit(1);
}
printf(" Input file: %s\n",infile);
printf("Output file: %s\n",outfile);
if (asm_context.debug_file==1)
{
char filename[1024];
strcpy(filename,outfile);
new_extension(filename, "ndbg", 1024);
dbg=fopen(filename,"wb");
if (dbg==NULL)
{
printf("Couldn't open %s for writing.\n",filename);
exit(1);
}
printf(" Debug file: %s\n",filename);
fprintf(dbg,"%s\n",infile);
}
if (create_list==1)
{
char filename[1024];
strcpy(filename,outfile);
new_extension(filename, "lst", 1024);
list=fopen(filename,"wb");
if (list==NULL)
{
printf("Couldn't open %s for writing.\n",filename);
exit(1);
}
printf(" List file: %s\n",filename);
}
printf("\n");
address_heap_init(&asm_context.address_heap);
defines_heap_init(&asm_context.defines_heap);
printf("Pass 1...\n");
asm_context.pass=1;
assemble_init(&asm_context);
error_flag=assemble(&asm_context);
if (error_flag!=0)
{
printf("** Errors... bailing out\n");
fclose(out);
unlink(outfile);
create_list=0;
}
else
{
address_heap_lock(&asm_context.address_heap);
// defines_heap_lock(&asm_context.defines_heap);
printf("Pass 2...\n");
asm_context.pass=2;
assemble_init(&asm_context);
error_flag=assemble(&asm_context);
if (format==FORMAT_HEX)
{
write_hex(&asm_context, out);
}
else
if (format==FORMAT_BIN)
{
write_bin(&asm_context, out);
}
#ifndef DISABLE_ELF
else
if (format==FORMAT_ELF)
{
write_elf(&asm_context, out);
}
#endif
if (dbg!=NULL)
{
for (i=0; i<65536; i++)
{
putc(asm_context.debug_line[i]>>8,dbg);
putc(asm_context.debug_line[i]&0xff,dbg);
}
fclose(dbg);
}
fclose(out);
}
#if 0
for (i=asm_context.low_address; i<=asm_context.high_address; i++)
{
printf("%04x: %d\n", i, asm_context.debug_line[i]);
}
#endif
if (create_list==1)
{
int *lines=NULL;
int line=1;
int ch;
fseek(asm_context.in, 0, SEEK_SET);
/* Build a map of lines to offset in source file (really more
of a map of lines to offset in debug_line which is an offset
to input file */
if (asm_context.line<65535)
{
lines=(int *)malloc((asm_context.line+1)*sizeof(int));
memset(lines, -1, (asm_context.line+1)*sizeof(int));
for (i=asm_context.high_address; i>=asm_context.low_address; i--)
{
if ((int)asm_context.debug_line[i]<0) continue;
lines[asm_context.debug_line[i]]=i;
}
}
/* Read input file again line by line and write back out to lst file.
If line matches something in the index, then output the line and
disassembled code */
while(1)
{
ch=getc(asm_context.in);
if (ch!=EOF) { putc(ch, list); }
if (ch=='\n' || ch==EOF)
{
int i;
int start;
if (lines==NULL)
{ start=asm_context.low_address; }
else
{
if (lines[line]>=0)
{
start=lines[line];
}
else
{
start=asm_context.high_address+1;
}
}
//int loop_count=0;
for (i=start; i<=asm_context.high_address; i++)
{
int num;
if (asm_context.debug_line[i]==line)
{
fprintf(list, "\n");
while(asm_context.debug_line[i]==line)
{
int cycles;
char instruction[128];
int count=msp430_disasm(asm_context.bin, i, instruction, &cycles);
num=asm_context.bin[i]|(asm_context.bin[i+1]<<8);
fprintf(list, "0x%04x: 0x%04x %-40s cycles: %d\n", i, num, instruction, cycles);
count--;
while (count>0)
{
i=i+2;
num=asm_context.bin[i]|(asm_context.bin[i+1]<<8);
fprintf(list, "0x%04x: 0x%04x\n", i, num);
count--;
}
i=i+2;
}
fprintf(list, "\n");
break;
}
//loop_count++;
}
//printf("loop_count=%d\n", loop_count);
if (ch==EOF) { break; }
line++;
}
}
if (lines!=NULL) free(lines);
assemble_print_info(&asm_context, list);
fclose(list);
}
assemble_print_info(&asm_context, stdout);
address_heap_free(&asm_context.address_heap);
defines_heap_free(&asm_context.defines_heap);
fclose(asm_context.in);
if (error_flag!=0)
{
printf("*** Failed ***\n\n");
unlink(outfile);
}
return 0;
}
