void
expire_grp()
{
int pos, fd;
char fgrp[80], fold[80], fnew[80];
SLOT grp;
pos = 0;
sprintf(fgrp, "2nd/%s", FN_GRP);
sprintf(fnew, "2nd/%s.new", FN_GRP);
fd = open(fnew, O_CREAT | O_TRUNC, 0600); // touch a new file
if(fd > 0) close(fd);
while(rec_get(fgrp, &grp, sizeof(SLOT), pos) != -1)
{
if(grp.prop & PROP_G_CANCEL)
{
sprintf(fold, "2nd/%s", grp.fn);
f_rm(fold);
}
else
{
rec_add(fnew, &grp, sizeof(SLOT));
}
pos++;
}
sprintf(fold, "2nd/%s.old", FN_GRP);
f_cp(fgrp, fold, O_TRUNC);
f_mv(fnew, fgrp);
return;
}
/*
* Read address at location and return updated location.
*/
db_addr_t
db_read_address(db_addr_t loc, int short_addr, int regmodrm, int rex,
struct i_addr *addrp)
{
int mod, rm, sib, index, disp, size;
size = (short_addr ? LONG : QUAD);
mod = f_mod(regmodrm);
rm = f_rm(regmodrm, rex);
if (mod == 3) {
addrp->is_reg = TRUE;
addrp->disp = rm;
return (loc);
}
addrp->is_reg = FALSE;
addrp->index = 0;
if (rm == 4 || rm == 12) {
get_value_inc(sib, loc, 1, FALSE);
rm = sib_base(sib, rex);
index = sib_index(sib, rex);
if (index != 4)
addrp->index = db_reg[size][index];
addrp->ss = sib_ss(sib);
}
switch (mod) {
case 0:
if (rm == 5) {
get_value_inc(addrp->disp, loc, 4, FALSE);
addrp->base = 0;
} else {
addrp->disp = 0;
addrp->base = db_reg[size][rm];
}
break;
case 1:
get_value_inc(disp, loc, 1, TRUE);
addrp->disp = disp;
addrp->base = db_reg[size][rm];
break;
case 2:
get_value_inc(disp, loc, 4, FALSE);
addrp->disp = disp;
addrp->base = db_reg[size][rm];
break;
}
return (loc);
}
int refriend(struct userec* user,char* arg)
{
char buf[256],buf2[256];
char cmd[1024];
sethomefile(buf,user->userid,"friends");
sethomefile(buf2,user->userid,"friends.sav");
f_cp(buf,buf2,O_TRUNC);
sethomefile(buf2,user->userid,"newfriends");
newfd=open(buf2,O_WRONLY|O_TRUNC|O_CREAT,0644);
apply_record(buf,(APPLY_FUNC_ARG)conver,sizeof(struct oldfriend),NULL,0,false);
close(newfd);
f_rm(buf);
f_mv(buf2,buf);
}
void
expire_item()
{
int pos, pos1, fd;
char fgrp[80], fitem[80], fname[80], fold[80], fnew[80];
time_t expire;
SLOT grp, item;
expire = time(0) - EXP * 86400;
pos = pos1 = 0;
sprintf(fgrp, "2nd/%s", FN_GRP);
while(rec_get(fgrp, &grp, sizeof(SLOT), pos) != -1)
{
sprintf(fitem, "2nd/%s/%s", grp.fn, FN_ITEM);
sprintf(fnew, "2nd/%s/%s.new", grp.fn, FN_ITEM);
fd = open(fnew, O_CREAT | O_TRUNC, 0600); // touch a new file
if(fd > 0) close(fd);
fd = 0;
while(rec_get(fitem, &item, sizeof(SLOT), pos1) != -1)
{
if((item.prop & PROP_I_CANCEL) || (item.chrono < expire))
{
sprintf(fname, "2nd/%s/%c/%s", grp.fn, item.fn[7], item.fn);
f_rm(fname);
}
else
{
fd++;
rec_add(fnew, &item, sizeof(SLOT));
}
pos1++;
}
sprintf(fold, "2nd/%s/%s.old", grp.fn, FN_ITEM);
f_cp(fitem, fold, O_TRUNC);
f_mv(fnew, fitem);
grp.reply = fd;
rec_put(fgrp, &grp, sizeof(SLOT), pos);
pos++;
}
return;
}
/*
* Disassemble floating-point ("escape") instruction
* and return updated location.
*/
db_addr_t
db_disasm_esc(db_addr_t loc, int inst, int short_addr, int size, int rex,
char *seg)
{
int regmodrm;
struct finst *fp;
int mod;
struct i_addr address;
char * name;
get_value_inc(regmodrm, loc, 1, FALSE);
fp = &db_Esc_inst[inst - 0xd8][f_reg(regmodrm, 0)];
mod = f_mod(regmodrm);
if (mod != 3) {
if (*fp->f_name == '\0') {
db_printf("<bad instruction>");
return (loc);
}
/*
* Normal address modes.
*/
loc = db_read_address(loc, short_addr, regmodrm, rex, &address);
db_printf("%s", fp->f_name);
switch (fp->f_size) {
case SNGL:
db_printf("s");
break;
case DBLR:
db_printf("l");
break;
case EXTR:
db_printf("t");
break;
case WORD:
db_printf("s");
break;
case LONG:
db_printf("l");
break;
case QUAD:
db_printf("q");
break;
default:
break;
}
db_printf("\t");
db_print_address(seg, BYTE, &address);
} else {
/*
* 'reg-reg' - special formats
*/
switch (fp->f_rrmode) {
case op2(ST,STI):
name = (fp->f_rrname) ? fp->f_rrname : fp->f_name;
db_printf("%s\t%%st,%%st(%d)",name, f_rm(regmodrm, 0));
break;
case op2(STI,ST):
name = (fp->f_rrname) ? fp->f_rrname : fp->f_name;
db_printf("%s\t%%st(%d),%%st",name, f_rm(regmodrm, 0));
break;
case op1(STI):
name = (fp->f_rrname) ? fp->f_rrname : fp->f_name;
db_printf("%s\t%%st(%d)",name, f_rm(regmodrm, 0));
break;
case op1(X):
name = ((char * const *)fp->f_rrname)[f_rm(regmodrm,0)];
if (*name == '\0')
goto bad;
db_printf("%s", name);
break;
case op1(XA):
name = ((char * const *)fp->f_rrname)[f_rm(regmodrm,0)];
if (*name == '\0')
goto bad;
db_printf("%s\t%%ax", name);
break;
default:
bad:
db_printf("<bad instruction>");
break;
}
}
return (loc);
}
/*
* Read address at location and return updated location.
*/
db_addr_t
db_read_address(db_addr_t loc, int short_addr, int regmodrm,
struct i_addr *addrp)
{
int mod, rm, sib, index, disp;
mod = f_mod(regmodrm);
rm = f_rm(regmodrm);
if (mod == 3) {
addrp->is_reg = TRUE;
addrp->disp = rm;
return (loc);
}
addrp->is_reg = FALSE;
addrp->index = 0;
if (short_addr) {
addrp->index = 0;
addrp->ss = 0;
switch (mod) {
case 0:
if (rm == 6) {
get_value_inc(disp, loc, 2, FALSE);
addrp->disp = disp;
addrp->base = 0;
} else {
addrp->disp = 0;
addrp->base = db_index_reg_16[rm];
}
break;
case 1:
get_value_inc(disp, loc, 1, TRUE);
disp &= 0xffff;
addrp->disp = disp;
addrp->base = db_index_reg_16[rm];
break;
case 2:
get_value_inc(disp, loc, 2, FALSE);
addrp->disp = disp;
addrp->base = db_index_reg_16[rm];
break;
}
} else {
if (rm == 4) {
get_value_inc(sib, loc, 1, FALSE);
rm = sib_base(sib);
index = sib_index(sib);
if (index != 4)
addrp->index = db_reg[LONG][index];
addrp->ss = sib_ss(sib);
}
switch (mod) {
case 0:
if (rm == 5) {
get_value_inc(addrp->disp, loc, 4, FALSE);
addrp->base = 0;
} else {
addrp->disp = 0;
addrp->base = db_reg[LONG][rm];
}
break;
case 1:
get_value_inc(disp, loc, 1, TRUE);
addrp->disp = disp;
addrp->base = db_reg[LONG][rm];
break;
case 2:
get_value_inc(disp, loc, 4, FALSE);
addrp->disp = disp;
addrp->base = db_reg[LONG][rm];
break;
}
}
return (loc);
}
/*
* Read address at location and return updated location.
*/
static db_addr_t
db_read_address(db_addr_t loc, int short_addr, int rex, int regmodrm,
struct i_addr *addrp)
{
int mod, rm, sib, index, disp, size, have_sib;
mod = f_mod(rex, regmodrm);
rm = f_rm(rex, regmodrm);
if (mod == 3) {
addrp->is_reg = TRUE;
addrp->disp = rm;
return (loc);
}
addrp->is_reg = FALSE;
addrp->index = NULL;
if (short_addr)
size = LONG;
else
size = QUAD;
if ((rm & 0x7) == 4) {
get_value_inc(sib, loc, 1, FALSE);
rm = sib_base(rex, sib);
index = sib_index(rex, sib);
if (index != 4)
addrp->index = db_reg[1][size][index];
addrp->ss = sib_ss(rex, sib);
have_sib = 1;
} else
have_sib = 0;
switch (mod) {
case 0:
if (rm == 5) {
get_value_inc(addrp->disp, loc, 4, FALSE);
if (have_sib)
addrp->base = NULL;
else if (short_addr)
addrp->base = "%eip";
else
addrp->base = "%rip";
} else {
addrp->disp = 0;
addrp->base = db_reg[1][size][rm];
}
break;
case 1:
get_value_inc(disp, loc, 1, TRUE);
addrp->disp = disp;
addrp->base = db_reg[1][size][rm];
break;
case 2:
get_value_inc(disp, loc, 4, FALSE);
addrp->disp = disp;
addrp->base = db_reg[1][size][rm];
break;
}
return (loc);
}
