/* J calls for wd commands - 3 is EVDOMAIN
x - 11!:x
w - A* argument
p1 - result (if not 0)
p2 - result (if p1==0)
p2==0 - result is mtm
p2 -> int type, int element count, integer or char data
type==0 - char result
type==1 - char result (to be cut and boxed on 0)
type==2 - int result
return error code (3 EVDOMAIN)
*/
int _stdcall JwdS(J jt, int x, A w, A* p1, int** p2)
{
int type;
SOCKBUF* pb;
/* binrep of user arg has 4 byte ints */
int* pi=(int*)CAV(w);
/* test for wd'q' - depends on 3!:1 format */
if(x==0 && LIT&pi[1] && 1==pi[2] && 0==pi[3] && 'q'==*(16+(C*)pi))
{
int* pi=geteventdata();
if(0==pi) return EVDOMAIN;
*p2=pi;
return 0; /* wd'q' result is ready */
}
if(x==0)
{
char* pl=JGetLocale(jt);
putdata(JCMDWD,x,AN(w),CAV(w),strlen(pl),pl);
}
else
putdata(JCMDWD,x,AN(w),CAV(w),0,0);
if(!(pb=getdata())) errorm("jwds getdata failed");
if(pb->cmd!=JCMDWDZ) errorm("jwds not wdz");
type = pb->type;
if(type>CTERR) return type-CTERR;
if(type==CTMTM) return 0;
*p2=(int*)&pb->type;
return 0;
}
static int32_t
verify_mic(struct client *client, int32_t hContext,
krb5_data *in, krb5_data *mic)
{
int32_t val;
put32(client, eVerify);
put32(client, hContext);
put32(client, 0);
put32(client, 0);
putdata(client, *in);
putdata(client, *mic);
ret32(client, val);
return val;
}
int main(int argc, char *argv[])
{
pid_t traced_process;
struct user_regs_struct regs;
long ins;
/* int 0x80, int3 */
char code[] = {0xcd,0x80,0xcc,0};
char backup[4];
if(argc != 2) {
printf("Usage: %s <pid %s to be traced>\n", argv[0], argv[1]);
exit(1);
}
traced_process = atoi(argv[1]);
ins = ptrace(PTRACE_ATTACH, traced_process, NULL, NULL);
if (ins == -1)
{
err_sys("ptrace PTRACE_ATTACH");
}
wait(NULL);
ptrace(PTRACE_GETREGS, traced_process, NULL, ®s);
// 先保存 寄存器
/* Copy instructions into a backup variable */
getdata(traced_process, regs.eip, backup, 3);
// 执行断点
/* Put the breakpoint */
putdata(traced_process, regs.eip, code, 3);
/* Let the process continue and execute
the int 3 instruction */
ptrace(PTRACE_CONT, traced_process, NULL, NULL);
wait(NULL);
printf("The process stopped, putting back the original instructions\n");
printf("Press <enter> to continue\n");
getchar();
// 恢复eip寄存器
putdata(traced_process, regs.eip, backup, 3);
/* Setting the eip back to the original
instruction to let the process continue */
// 恢复寄存器，继续执行
ptrace(PTRACE_SETREGS, traced_process, NULL, ®s);
ptrace(PTRACE_DETACH, traced_process, NULL, NULL);
return 0;
}
void run(void* jt)
{
I r,n,len;A a;SOCKBUF* pb;static C setname[nsz+1]="";
while(1)
{
pb=getdata();
if(!pb) errorm("run getdata failed");
len = pb->len;
switch(pb->cmd)
{
case JCMDDO:
if(pb->type==1) /* input and event data */
{
seteventdata();
len=strlen(pb->d);
}
if(len<sizeof(input)-1)
{
memcpy(input, pb->d, len);
input[len]=0;
r=JDo(jt,input);
}
else
r=EVLENGTH;
putdata(JCMDDOZ,r,0,0,0,0);
break;
case JCMDSETN:
n=len<nsz?len:nsz;
memcpy(setname, pb->d, n);
setname[n]=0;
break;
case JCMDSET:
r=JSetA(jt,strlen(setname),setname,len,pb->d);
putdata(JCMDSETZ,r,0,0,0,0);
break;
case JCMDGET:
a=JGetA(jt,len,pb->d);
if(a==0)
putdata(JCMDGETZ,EVVALUE,0,0,0,0);
else
putdata(JCMDGETZ,0,AN(a),CAV(a),0,0);
break;
default:
errorm("unknown command");
}
}
}
// run-length decoding scheme
void
rldecode(int infd, int outfd)
{
// sanity checks
MustBeTrue(infd >= 0 && outfd >= 0);
// read in file and encode
unsigned char data1, data2, data3;
while (getdata(infd, data1) > 0)
{
if (data1 != EscapeValue)
{
// just write the data out
MustBeTrue(putdata(outfd, data1) == 1);
}
else
{
// we have a possible runcount and value
MustBeTrue(getdata(infd, data2) > 0);
if (data2 == ZeroValue)
{
// write out escape value
MustBeTrue(putdata(outfd, data1) == 1);
}
else
{
// get data to write
MustBeTrue(getdata(infd, data3) > 0);
for (unsigned char i=0; i<=data2; i++)
{
MustBeTrue(putdata(outfd, data3) == 1);
}
}
}
}
// flush output buffer
MustBeTrue(flushout(outfd) == 1);
// close files
MustBeTrue(infd == 0 || close(infd) == OK);
MustBeTrue(outfd == 1 || close(outfd) == OK);
// all done
return;
}
static int32_t
unwrap_token_ext(struct client *client, int32_t hContext, int32_t flags,
int32_t bflags, krb5_data *header, krb5_data *in, krb5_data *trailer,
krb5_data *out)
{
int32_t val;
put32(client, eUnwrapExt);
put32(client, hContext);
put32(client, flags);
put32(client, bflags);
putdata(client, *header);
putdata(client, *in);
putdata(client, *trailer);
ret32(client, val);
retdata(client, *out);
return val;
}
int main(int argc, char **argv){
int status;
pid_t pid;
long orig_eax, eax;
struct user_regs_struct regs;
char *str;
long ins;
int len = 41;
char code[] = "\xeb\x15\x5e\xb8\x04\x00\x00\x00"
"\xbb\x02\x00\x00\x00\x89\xf1\xba"
"\xc0\x00\x00\x00\xcd\x80\xcc\xe8"
"\xe6\xff\xff\xff\x48\x65\x6c\x6c"
"\x6f\x20\x57\x6f\x72\x6c\x64\x0a\x00"
;
char backup[len];
if(argc != 2){
printf("Usage : %s <pid>\n", argv[0]);
exit(-1);
}
pid = atoi(argv[1]);
ptrace(PTRACE_ATTACH, pid, NULL, NULL);
wait(&status);
ptrace(PTRACE_GETREGS, pid, NULL, ®s);
// back up the cuurent instruction
getdata(pid, regs.eip, backup, len);
// put the breakpoint
putdata(pid, regs.eip, code, len);
// let the process continue and execute the int3 instruction
ptrace(PTRACE_SETREGS, pid, NULL, ®s);
ptrace(PTRACE_CONT, pid, NULL, NULL);
wait(&status);
printf("The process stopped, putting back the original ins\n");
//printf("Press <enter> to continue\n");
//getchar();
putdata(pid, regs.eip, backup, len);
// set EIP back to the stopped instruction
ptrace(PTRACE_SETREGS, pid, NULL, ®s);
ptrace(PTRACE_DETACH, pid, NULL, NULL);
//printf("Tracer Exit...\n");
return 0;
}
int EDFfilehandler::writeannotbuffer(int recnum){
//fseek(f,bytesinheader+sizeof(short signed)*(recsize*recnum+edfdatarecoffset[annotsignal]),SEEK_SET);
//fwrite(annotbuffer,samplesperrecord[annotsignal],sizeof(signed short),f);
short int v;
for (int i=0;i<samplesperrecord[annotsignal];i++){
v=annotbuffer[2*i+1]*256+annotbuffer[2*i];
putdata(annotsignal,recnum*samplesperrecord[annotsignal]+i,v);
}
return 1;
}
int main()
{
pid_t child;
child = fork();
if(child == 0)
{
ptrace(PTRACE_TRACEME, 0, NULL, NULL);
execl("/bin/ls", "ls", NULL);
}
else {
long orig_eax;
long params[3];
int status;
char *str, *laddr;
int toggle = 0;
while(1)
{
wait(&status);
if(WIFEXITED(status))
break;
orig_eax = ptrace(PTRACE_PEEKUSER,
child, 4 * ORIG_EAX,
NULL);
if(orig_eax == SYS_write)
{
if(toggle == 0)
{
toggle = 1;
params[0] = ptrace(PTRACE_PEEKUSER,
child, 4 * EBX,
NULL);
params[1] = ptrace(PTRACE_PEEKUSER,
child, 4 * ECX,
NULL);
params[2] = ptrace(PTRACE_PEEKUSER,
child, 4 * EDX,
NULL);
str = (char*)malloc((params[2]+1)
*sizeof(char));
getdata(child, params[1], str,
params[2]);
reverse(str);
putdata(child, params[1], str,
params[2]);
}
else {
toggle = 0;
}
}
//继续child的调用
ptrace(PTRACE_SYSCALL, child, NULL, NULL);
}
}
return 0;
}
int main(int argc, char ** argv)
{
printf ("In main of %s: argc=%d\n",argv[0], argc);
if (argc < 3) {
usage();
exit (1);
}
if (0 == strcmp(argv[1],"-c")) {
createdevice(argv[2]);
}
else if (0 == strcmp(argv[1],"-r")) {
removedevice(argv[2]);
}
else if (0 == strcmp(argv[1], "-p")) {
if (argc < 4)
goto usage;
putdata(argv[2], argv[3]);
}
else if (0 == strcmp(argv[1], "-g")) {
if (argc < 4)
goto usage;
if (0 == strcmp(argv[3], "new")) {
getnewdata(argv[2]);
} else {
getolddata(argv[2]);
}
} else if (0 == strcmp(argv[1], "-ga")) {
getalldata(argv[2]);
} else if (0 == strcmp(argv[1], "-gb")) {
getwithwait(argv[2]);
} else if (0 == strcmp(argv[1], "-s")) {
if (argc < 4)
goto usage;
selecttest(argv[2], argv[3]);
} else {
goto usage;
}
return 0;
usage:
usage();
exit(1);
return 1;
}
/*This function inserts data at a certain place in the array (index).
This function calls the function putdata*/
void insertdata(struct dynamic_array** headref, int index, int data)
{
if(*headref==NULL){
putdata(headref,index,data);
}
else{
struct dynamic_array* current = *headref;
struct dynamic_array* prevcur;
while((current!=NULL)&&(current->index!=index)){
prevcur = current;
current = current->next;
}
if(current!=NULL){
current->data = data;
}
else{
putdata(&(prevcur->next),index,data);
}
}
}
int main()
{
int n, ip[NMAXSQRT + 2];
double a[NMAX + 1], w[NMAX * 5 / 4], t[NMAX / 2 + 1], err;
printf("data length n=? (must be 2^m)\n");
scanf("%d", &n);
ip[0] = 0;
/* check of CDFT */
putdata(0, n - 1, a);
cdft(n, 1, a, ip, w);
cdft(n, -1, a, ip, w);
err = errorcheck(0, n - 1, 2.0 / n, a);
printf("cdft err= %g \n", err);
/* check of RDFT */
putdata(0, n - 1, a);
rdft(n, 1, a, ip, w);
rdft(n, -1, a, ip, w);
err = errorcheck(0, n - 1, 2.0 / n, a);
printf("rdft err= %g \n", err);
/* check of DDCT */
putdata(0, n - 1, a);
ddct(n, 1, a, ip, w);
ddct(n, -1, a, ip, w);
a[0] *= 0.5;
err = errorcheck(0, n - 1, 2.0 / n, a);
printf("ddct err= %g \n", err);
/* check of DDST */
putdata(0, n - 1, a);
ddst(n, 1, a, ip, w);
ddst(n, -1, a, ip, w);
a[0] *= 0.5;
err = errorcheck(0, n - 1, 2.0 / n, a);
printf("ddst err= %g \n", err);
/* check of DFCT */
putdata(0, n, a);
a[0] *= 0.5;
a[n] *= 0.5;
dfct(n, a, t, ip, w);
a[0] *= 0.5;
a[n] *= 0.5;
dfct(n, a, t, ip, w);
err = errorcheck(0, n, 2.0 / n, a);
printf("dfct err= %g \n", err);
/* check of DFST */
putdata(1, n - 1, a);
dfst(n, a, t, ip, w);
dfst(n, a, t, ip, w);
err = errorcheck(1, n - 1, 2.0 / n, a);
printf("dfst err= %g \n", err);
return 0;
}
static int32_t
decrypt_token(struct client *client, int32_t hContext, int flags,
krb5_data *in, krb5_data *out)
{
int32_t val;
put32(client, eDecrypt);
put32(client, hContext);
put32(client, flags);
put32(client, 0);
putdata(client, *in);
ret32(client, val);
retdata(client, *out);
return val;
}
sendtones(unsigned char tonebyte[NPATCH][NCODPARAM]) /* send all compressed patches */
{ /* returns -1 if checksum error, -2 if user hits ESC */
int set, checksum, tone, byte, lsnib, msnib, n;
puts("\nSending patch data .......");
for ( set = 0; set < 16; set++){ /* for each set of 4 patches */
checksum = 0;
if (kbhit()){
if (getch() == ESC) /* allow user to quit - ESC key */
return(-1);
}
putdata(EXCL); /* send exclusive data message header */
putdata(ROLID);
putdata(MIDDAT);
putdata(0);
putdata(AJUNOF);
for (tone = set*4; tone < (set*4) + 4; tone++){
for (byte = 0; byte < NCODPARAM; byte++){
n = tonebyte[tone][byte];
lsnib = (n & 0x0f);
msnib = (n & 0xf0) >> 4;
putdata(lsnib);
putdata(msnib);
checksum = lsnib + msnib + checksum;
}
}
checksum = (0 - checksum) & 0x7f; /* ajuno expects checksum */
putdata(checksum); /* added to this no == 0 */
putdata(ENDEXCL);
n = getexcl();
if (n != MIDACK)
puts("\nDid not get ACK from synth, possible data error.");
}
sendexcl(MIDEOF); /* send EOF message */
n = getexcl();
return(n);
}
sendexcl(unsigned int code) /* send midi exclusive message */
{
putdata(EXCL); /* send exclusive data message header */
putdata(ROLID);
putdata(code);
putdata(0);
putdata(AJUNOF);
putdata(ENDEXCL);
}
int main(int argc, char **argv){
int status;
pid_t pid;
long orig_eax, eax;
struct user_regs_struct regs;
char *str;
long ins;
// int 0x80, int3
char code[] = {0xcd, 0x80, 0xcc, 0};
char backup[4];
if(argc != 2){
printf("Usage : %s <pid>\n", argv[0]);
exit(-1);
}
pid = atoi(argv[1]);
ptrace(PTRACE_ATTACH, pid, NULL, NULL);
wait(&status);
ptrace(PTRACE_GETREGS, pid, NULL, ®s);
// back up the cuurent instruction
getdata(pid, regs.eip, backup, 3);
// put the breakpoint
putdata(pid, regs.eip, code, 3);
// let the process continue and execute the int3 instruction
ptrace(PTRACE_CONT, pid, NULL, NULL);
wait(&status);
printf("The process stopped, putting back the original ins\n");
printf("Press <enter> to continue\n");
getchar();
putdata(pid, regs.eip, backup, 3);
// set EIP back to the stopped instruction
ptrace(PTRACE_SETREGS, pid, NULL, ®s);
ptrace(PTRACE_DETACH, pid, NULL, NULL);
printf("Tracer Exit...\n");
return 0;
}
uint8_t show_BH1750_Bright(struct bhl1750 *bright){
if ( Semaphore_getCount(brightDataHandle) == 0 ) {
//putstr("\r\nRead Brightness Data blocked!\r\n");
}else{
Semaphore_pend(brightDataHandle, BIOS_WAIT_FOREVER);
putstr("\r\nBrightness: ");
putdata(bright->SensBrightness);
putstr(" Lux ");
Semaphore_post(brightDataHandle);
}
return 0;
}
static int
HandleOP(Unwrap)
{
OM_uint32 maj_stat, min_stat;
int32_t hContext, flags, seqno;
krb5_data token;
gss_ctx_id_t ctx;
gss_buffer_desc input_token, output_token;
int conf_state;
gss_qop_t qop_state;
ret32(c, hContext);
ret32(c, flags);
ret32(c, seqno);
retdata(c, token);
ctx = find_handle(c->handles, hContext, handle_context);
if (ctx == NULL)
errx(1, "unwrap: reference to unknown context");
input_token.length = token.length;
input_token.value = token.data;
maj_stat = gss_unwrap(&min_stat, ctx, &input_token,
&output_token, &conf_state, &qop_state);
if (maj_stat != GSS_S_COMPLETE)
errx(1, "gss_unwrap failed: %d/%d", maj_stat, min_stat);
krb5_data_free(&token);
if (maj_stat == GSS_S_COMPLETE) {
token.data = output_token.value;
token.length = output_token.length;
} else {
token.data = NULL;
token.length = 0;
}
put32(c, 0); /* XXX fix gsm_error */
putdata(c, token);
if (maj_stat == GSS_S_COMPLETE)
gss_release_buffer(&min_stat, &output_token);
return 0;
}
int ptrace_call(pid_t pid, uint32_t addr, long *params, uint32_t num_params, struct pt_regs* regs)
{
uint32_t i;
for (i = 0; i < num_params && i < 4; i ++) {
regs->uregs[i] = params[i];
}
//
// push remained params onto stack
//
if (i < num_params) {
regs->ARM_sp -= (num_params - i) * sizeof(long) ;
putdata(pid, regs->ARM_sp, (char*)¶ms[i], (num_params - i) * sizeof(long));
}
regs->ARM_pc = addr;
if (regs->ARM_pc & 1) {
/* thumb */
regs->ARM_pc &= (~1u);
regs->ARM_cpsr |= CPSR_T_MASK;
} else {
/* arm */
regs->ARM_cpsr &= ~CPSR_T_MASK;
}
regs->ARM_lr = 0;
if (ptrace_setregs(pid, regs) == -1
|| ptrace_continue(pid) == -1) {
printf("error\n");
return -1;
}
int stat = 0;
waitpid(pid, &stat, WUNTRACED);
while (stat != 0xb7f) {
if (ptrace_continue(pid) == -1) {
printf("error\n");
return -1;
}
waitpid(pid, &stat, WUNTRACED);
}
return 0;
}
char* _stdcall JinputS(J jt, char* prompt)
{
I n,len;SOCKBUF* pb;
putdata(JCMDIN,0,strlen(prompt),prompt,0,0);
if(!(pb=getdata())) errorm("jinputs getdata failed");
if(pb->cmd!=JCMDINZ) errorm("jinputs not inz");
if(pb->type==1)
{
seteventdata();
len=strlen(pb->d); /* input followed by event data */
}
else
len = pb->len;
n=min(len,sizeof(input)-1);
memcpy(input, &pb->d, n);
input[n]=0;
return input;
}
static int
accept_sec_context(struct client *client,
int32_t *hContext,
int32_t flags,
const krb5_data *itoken,
krb5_data *otoken,
int32_t *hDelegCred)
{
int32_t val;
krb5_data_zero(otoken);
put32(client, eAcceptContext);
put32(client, *hContext);
put32(client, flags);
putdata(client, *itoken);
ret32(client, *hContext);
ret32(client, val);
retdata(client, *otoken);
ret32(client, *hDelegCred);
return val;
}
static int
init_sec_context(struct client *client,
int32_t *hContext, int32_t *hCred,
int32_t flags,
const char *targetname,
const krb5_data *itoken, krb5_data *otoken)
{
int32_t val;
krb5_data_zero(otoken);
put32(client, eInitContext);
put32(client, *hContext);
put32(client, *hCred);
put32(client, flags);
putstring(client, targetname);
putdata(client, *itoken);
ret32(client, *hContext);
ret32(client, val);
retdata(client, *otoken);
return val;
}
int main()
{
int choice;
char filename[200] = {0};
get_fold_id();
printf("Enetr ur choice\n 1.auth_tok\n 2.refresh_tok\n 3.putdata\n 4.down_data \n 5.read_fold\n 6.Create Folder\n");
scanf("%d",&choice);
if(choice == 1)
auth_tok();
if(choice == 2){
get_toks();
refresh_tok();
}
//read_fold();
//uplaod_data();
if(choice == 3){
printf("\nEnter File name: ");
gets(filename);
get_toks();
putdata("downfile.txt",fold_id);
}
if(choice ==4)
{
get_toks();
down_data();
}
if(choice ==5){
get_toks();
read_fold();
}
if(choice ==6){
get_toks();
create_fold();
}
main();
}
static void tracePro(int pid){
printf("Attached success: %d.\n", pid);
long scno = 0;
long regv = 0;
struct pt_regs regs;
char *str;
scno = getSysCallNo(pid, ®s);
// TODO ... getdata 和 putdata 的字符串处理逻辑有问题.
if(scno == __NR_write){
printf("Call __NR_write. \n");
str = (char*)calloc(1, (regs.ARM_r2+1) * sizeof(char));
printf("start getdata. \n");
getdata(pid, regs.ARM_r1, str, regs.ARM_r2);
printf("end getdata: %s.\n", str);
reverse(str);
printf("start putdata. \n");
putdata(pid, regs.ARM_r1, str, regs.ARM_r2);
printf("end putdata. \n");
}
}
static int
HandleOP(Sign)
{
OM_uint32 maj_stat, min_stat;
int32_t hContext, flags, seqno;
krb5_data token;
gss_ctx_id_t ctx;
gss_buffer_desc input_token, output_token;
ret32(c, hContext);
ret32(c, flags);
ret32(c, seqno);
retdata(c, token);
ctx = find_handle(c->handles, hContext, handle_context);
if (ctx == NULL)
errx(1, "sign: reference to unknown context");
input_token.length = token.length;
input_token.value = token.data;
maj_stat = gss_get_mic(&min_stat, ctx, 0, &input_token,
&output_token);
if (maj_stat != GSS_S_COMPLETE)
errx(1, "gss_get_mic failed");
krb5_data_free(&token);
token.data = output_token.value;
token.length = output_token.length;
put32(c, 0); /* XXX fix gsm_error */
putdata(c, token);
gss_release_buffer(&min_stat, &output_token);
return 0;
}
main(int argc, char *argv[])
{
float wrkbuff0[maxsize],wrkbuff1[maxsize];
char fil_in[100];
int j, ne, skip, size, nf, maxproj;
strcpy(fil_in,argv[1]);
getdata(&size,&maxproj,&wrkbuff0[0],fil_in);
skip=atoi(argv[2]);
fprintf(stderr,"shuffling every %d fid\n", maxproj/skip);
for (ne=0;ne<maxproj/skip;ne++)
{
for (nf=0;nf<skip;nf++)
{
for (j=0;j<size;j++)
{
wrkbuff1[(nf+ne*skip)*size+j] = wrkbuff0[(nf*maxproj/skip+ne)*size+j];
}
}
}
putdata(&size,&wrkbuff1[0],fil_in);
}
int main()
{ pid_t child;
long orig_eax;
child = fork();
int val;
long params[3];
int toggle=0;
char *str, *laddr;
if(child == 0)
{
ptrace(PTRACE_TRACEME, 0, NULL, NULL);
execl("./hello", "hello", NULL);
}
else
{
wait(NULL);
orig_eax = ptrace(PTRACE_PEEKUSER,
child,ORIG_EAX*4,
NULL);
printf("The child made a "
"system call %ld\n", orig_eax);
//ptrace(PTRACE_CONT, child, NULL, NULL);
ptrace(PTRACE_SYSCALL,child,NULL,NULL);
while(1)
{
wait(&val); //wait the signals.
if(WIFEXITED(val)) //judge if the child process exit.
return 0;
orig_eax = ptrace(PTRACE_PEEKUSER,
child, 4 * ORIG_EAX,
NULL);
if(orig_eax == SYS_write) // SYS_write = 4
{
if(toggle == 0) //get the signals for child process call SYS_write.
{
printf("inject the process !\n");
toggle = 1;
params[0] = ptrace(PTRACE_PEEKUSER,
child, 4 * EBX,
NULL);
params[1] = ptrace(PTRACE_PEEKUSER,
child, 4 * ECX,
NULL);
params[2] = ptrace(PTRACE_PEEKUSER,
child, 4 * EDX,
NULL);
str = (char *)malloc((params[2]+1) * sizeof(char));
getdata(child, params[1], str,
params[2]);
reverse(str);
putdata(child, params[1], str,
params[2]);
}
else //get the signals for child process exit call SYS_write.
{
toggle = 0;
}
}
ptrace(PTRACE_SYSCALL,child,NULL,NULL);
}
}
return 0;
}
void apollo_kbd_device::getchar(UINT8 data)
{
static const UINT8 ff1116_data[] = { 0x00, 0xff, 0x00 };
LOG1(("getchar <- %02x", data));
if (m_keyboard_tty.isConnected())
{
m_keyboard_tty.putchar(data);
}
if (data == 0xff)
{
m_rx_message = data;
putdata(&data, 1);
m_loopback_mode = 1;
}
else if (data == 0x00)
{
if (m_loopback_mode)
{
set_mode(KBD_MODE_0_COMPATIBILITY);
m_loopback_mode = 0;
}
}
else
{
m_rx_message = m_rx_message << 8 | data;
switch (m_rx_message)
{
case 0xff00:
putdata(&data, 1);
m_mode = KBD_MODE_0_COMPATIBILITY;
m_loopback_mode = 0;
m_rx_message = 0;
case 0xff01:
putdata(&data, 1);
m_mode = KBD_MODE_1_KEYSTATE;
m_rx_message = 0;
break;
case 0xff11:
putdata(&data, 1);
break;
case 0xff1116:
putdata(ff1116_data, sizeof(ff1116_data));
m_loopback_mode = 0;
m_rx_message = 0;
break;
case 0xff1117:
m_rx_message = 0;
break;
case 0xff12:
putdata(&data, 1);
break;
case 0xff1221: // receive ID message
m_loopback_mode = 0;
putdata(&data, 1);
if (keyboard_is_german())
{
putstring("3-A\r2-0\rSD-03863-MS\r");
}
else
{
putstring("3-@\r2-0\rSD-03863-MS\r");
}
if (m_mode == KBD_MODE_0_COMPATIBILITY)
{
set_mode(KBD_MODE_0_COMPATIBILITY);
}
else
{
set_mode(KBD_MODE_1_KEYSTATE);
}
m_rx_message = 0;
break;
case 0xff2181: // beeper on (for 300 ms)
putdata(&data, 1);
m_rx_message = 0;
m_beeper.on();
break;
case 0xff2182: // beeper off
putdata(&data, 1);
m_rx_message = 0;
m_beeper.off();
break;
default:
if (m_loopback_mode && data != 0)
{
putdata(&data, 1);
}
break;
}
}
}
void apollo_kbd_device::putstring(const char *data)
{
putdata((UINT8 *) data, strlen(data));
}
int outbuffer::putdata(const void *data, unsigned int len, bool autoresize)
{
if (freebytes()>=len)
return putdata(data,len,autoresize);
int wrn=flush(fd);
if (wrn<0)
return wrn;
while (len>0) {
int wr=::write(fd,data,len);
if (wr<0)
return wr;
data=(char*)data+wr;
len-=wr;
wrn+=wr;
wrtot+=wr;
}
return wrn;
}
