int recu(int num){
printf("Stack: %d, ESP: %d, Iteration: %d\n", getStack((int)(getp()->stack)), getp()->esp, num);
int a[200];
a[2] = 1;
if(num == 0){
return 1;
}
else if( num%5 ){
softyield();
}
recu(num-1);
return 1;
}
static int
process_script(CexpParserCtx ctx, char *name, int quiet)
{
int rval = 0;
FILE *filestack[ST_DEPTH];
int sp=-1;
char buf[500]; /* limit line length to 500 chars :-( */
int i;
sprintf(buf,"<%s\n",name);
goto skipFirstPrint;
do {
register char *p;
if ( !quiet ) {
for ( i=0; i<=sp; i++ )
printf(" ");
printf("%s", buf);
fflush(stdout);
}
skipFirstPrint:
p = skipsp(buf);
if ( '<' == *p ) {
/* extract path */
p = getp(p+1);
/* PUSH a new script on the stack */
if ( !quiet ) {
for ( i=0; i<=sp; i++ )
fputc('<',stdout);
printf("'%s':\n",p);
}
if ( ++sp >= ST_DEPTH || !(filestack[sp] = fopen(p,"r")) ) {
if ( sp >= ST_DEPTH ) {
fprintf(stderr,"Scripts too deply nested (only %i levels supported)\n",ST_DEPTH);
rval = CEXP_MAIN_NO_MEM;
} else {
rval = CEXP_MAIN_NO_SCRIPT;
perror("opening script file");
}
sp--;
}
} else {
/* handle simple comments as a courtesy... */
if ( '#' != *p ) {
cexpResetParserCtx(ctx,buf);
cexpparse((void*)ctx);
}
}
while ( sp >= 0 && !fgets(buf, sizeof(buf), filestack[sp] ) ) {
/* EOF reached; POP script off */
fclose(filestack[sp]);
sp--;
}
} while ( sp >= 0 );
return rval;
}
void fault_handler(struct regs *r)
{
// if (r->int_no < 32)
// {
// printf("%s", exception_messages[r->int_no]);
// printf(" Exception.\n");
// }
char esp=r->int_no;
// printf("killin process"); Nunca va a funcionar xq no se lo ejecuta desde una terminal
sigkill_h(getp());
int a=0;
for(a;a<strlen(exception_messages[esp]);a++){
*(char*)(0xb8410 + 80*2*(rxz+1) + 2*a) = exception_messages[esp][a];
}
// *(char*)(0xb8410 + 80*2*rxz) = esp % 10 + '0';
// *(char*)(0xb840e + 80*2*rxz) = (esp / 10) % 10 + '0';
// *(char*)(0xb840c + 80*2*rxz) = (esp / 100) % 10 + '0';
// *(char*)(0xb840a + 80*2*rxz) = (esp / 1000) % 10 + '0';
// *(char*)(0xb8408 + 80*2*rxz) = (esp / 10000) % 10 + '0';
// *(char*)(0xb8406 + 80*2*rxz) = (esp / 100000) % 10 + '0';
// *(char*)(0xb8404 + 80*2*rxz) = (esp / 1000000) % 10 + '0';
// *(char*)(0xb8402 + 80*2*rxz) = (esp / 10000000) % 10 + '0';
// *(char*)(0xb8400 + 80*2*rxz) = (esp / 100000000) % 10 + '0';
// }
rxz++;
_Sti();
}
int main(void)
{
int a;
char buf[10] = "qwer";
char * p;
char * argv[10];
char * p1;
head = (char *)malloc(2);
head[0] = '7';
printf("p1 = 0x%x\n", p1);
printf("&p1 = 0x%x\n", &p1);
getp(&p1);
a = (int)p1;
free(p1);
//free(a);
printf("p1 = 0x%x\n", p1);
printf("*p1 = %c\n", *p1);
return 0;
parse(buf, argv);
return 0;
}
/**
* @brief OutputSize
* @param imgIn
* @param width
* @param height
* @param channels
* @param frames
*/
void OutputSize(ImageVec imgIn, int &width, int &height, int &channels, int &frames)
{
width = imgIn[0]->width;
height = imgIn[0]->height;
channels = getp(imgIn)->channels * (getI(imgIn)->channels + 1);
frames = imgIn[0]->frames;
}
int main()
{
int r, c;
scanf("%d %d", &r, &c);
memset(f, 0, sizeof(f));
for (int i = 1; i <= r; ++i)
{
scanf("%s", s[i] + 1);
getp(i, c);
int j = c;
do {
j = p[j];
++f[c-j];
} while (p[j]);
}
int i, x, y;
for (i = 1; i < c; ++i)
if (f[i] == r)
break;
x = i;
y = getp_r(r);
printf("%d\n", x * y);
return 0;
}
void solve(std::istream& in, std::ostream& out) {
int t;
in>>t;
while(t--){
in>>a;
in>>b;
n = strlen(a), m = strlen(b);
getp();
out<<kmp()+1<<endl;
}
}
bool TLVExecutor::execute(Cmd& cmd)
{
if(cmd.size() < 2)
{
log("Error cmd with no params:%s", printCmd(cmd));
return false;
}
const char* key = cmd[0].c_str();
if(0 == strcasecmp("settag", key))
{
CheckParam(2);
return TLVInterface::setTag(atoi(getp(1)),getp(2));
}
else if(0 == strcasecmp("gettag", key))
{
CheckParam(2);
return TLVInterface::getTag(atoi(getp(1)),getp(2));
}
else if(0 == strcasecmp("addtag", key))
{
CheckParam(2);
return TLVInterface::addTag(atoi(getp(1)),getp(2));
}
return false;
}
PIC_INLINE void FilterGuidedAB::ProcessBBox(Image *dst, ImageVec src,
BBox *box)
{
Image *I = getI(src);
Image *p = getp(src);
if(I->channels == 1) {
Process1Channel(I, p, dst, box);
}
if(I->channels == 3) {
Process3Channel(I, p, dst, box);
}
}
number AMSStat::check(char * name){
int thread=0;
#ifdef _OPENMP
#ifdef G4MULTITHREADED
int id=G4Threading::G4GetThreadId();
if(id<0)return 0 ;
else thread=id;
#else
thread=omp_get_thread_num();
#endif
#endif
AMSStatNode *p=(AMSStatNode*)getp(AMSID(name,thread));
if(p){
return HighResTime()-p->_time;
}
else return 0;
}
number AMSStat::Get(char *name){
int thread=0;
#ifdef _OPENMP
#ifdef G4MULTITHREADED
int id=G4Threading::G4GetThreadId();
if(id<0)return 0;
else thread=id;
#else
thread=omp_get_thread_num();
#endif
#endif
AMSStatNode *p=(AMSStatNode*)getp(AMSID(name,thread));
if(p &&p->_startstop==0)
return p->_last;
else return 0;
}
void AMSStat::print(char *name){
int thread=0;
#ifdef _OPENMP
#ifdef G4MULTITHREADED
int id=G4Threading::G4GetThreadId();
if(id<0)return ;
else thread=id;
#else
thread=omp_get_thread_num();
#endif
#endif
AMSStatNode *p=(AMSStatNode*)getp(AMSID(name,thread));
if(p){
printf(" Name Entries Min Average Max Sum\n");
p->print(cout);
}
}
bool load_data(char *fname, st_matrix *mtx) {
FILE *ifile = fopen(fname, "r");
if(!ifile) {
return false;
}
size_t i;
size_t j;
for(i = 0; i < mtx->nrow; ++i) {
for(j = 0; j < mtx->ncol; ++j) {
if(fscanf(ifile, "%lf", getp(mtx, i, j)) == EOF) {
fclose(ifile);
return false;
}
}
}
fclose(ifile);
return true;
}
number AMSStat::stop(char *name, integer force){
int thread=0;
#ifdef _OPENMP
#ifdef G4MULTITHREADED
int id=G4Threading::G4GetThreadId();
if(id<0)return 0;
else thread=id;
#else
thread=omp_get_thread_num();
#endif
#endif
AMSStatNode *p=(AMSStatNode*)getp(AMSID(name,thread));
number time=0;
if(p){
if(p->_startstop==1){
number tt=HighResTime();
time=tt-p->_time;
if(time<-0.001){
cerr<<" AMSStat-E-BadTime "<<name<<" "<<thread<<" "<<" "<<time<<" "<<tt<<" "<<p->_time<<endl;
p->_startstop=0;
return 0;
}
p->_entry=p->_entry+1;
p->_time=tt;
p->_last=time;
p->_sum=p->_sum+time;
p->_sum2=p->_sum*p->_sum;
if(time > p->_max)p->_max=time;
if(time < p->_min)p->_min=time;
p->_startstop=0;
#ifdef __LVL3ONLY__
fbin << p->_entry<<" "<< time<<endl;
#endif
}
else if(!force)cerr<<"AMSStat-Stop-W-NTSTRTD "<<name<<" was not started"<<endl;
}
#ifdef __LVL3ONLY__
#else
else cerr<<"AMSStat-Stop-E-Name "<<name<<" does not exist"<<endl;
#endif
return time;
}
int main(void)
{
char * p;
int i;
// p = getp();
// *p = 'a';
p = getp(0);
PRINT(p);
PRINT(*p);
free(p);
for (i = 0; i < 20; i++)
{
*(p+i) = 'a';
PRINT(*(p+i));
}
//p = NULL;
//p = getp(0);
PRINT(p);
PRINT(*(p+15));
return 0;
p = getp(1);
*p = 'a';
PRINT(p);
return 0;
a();
p = getp(1);
//free(p);
printf("ret = %s\n", getp(0));
printf("ret = %s\n", getp(1));
printf("ret = %s, %s\n", getp(0), getp(1));
// PRINT(*p);
return 0;
}
void AMSStat::start(char *name){
int thread=0;
#ifdef _OPENMP
#ifdef G4MULTITHREADED
int id=G4Threading::G4GetThreadId();
if(id<0)return ;
else thread=id;
#else
thread=omp_get_thread_num();
#endif
#endif
AMSStatNode *p=(AMSStatNode*)getp(AMSID(name,thread));
if(p){
p->_time=HighResTime();
p->_startstop=1;
}
#ifdef __LVL3ONLY__
#else
else cerr<<"AMSStat-Start-E-Name "<<name<<" "<<thread<<" does not exist"<<endl;
#endif
}
dropbear_dss_key * gen_dss_priv_key(unsigned int size) {
dropbear_dss_key *key;
if (size != 1024) {
dropbear_exit("DSS keys have a fixed size of 1024 bits");
}
key = m_malloc(sizeof(*key));
m_mp_alloc_init_multi(&key->p, &key->q, &key->g, &key->y, &key->x, NULL);
getq(key);
getp(key, size/8);
getg(key);
getx(key);
gety(key);
return key;
}
void AMSStat::accu(){
AMSStatNode * cur;
for (int i=0;;){
cur=(AMSStatNode*)getid(i++); // get one by one
if(cur){
if(cur->getid()!=0 && cur->_entry>0){
AMSStatNode *p=(AMSStatNode*)getp(AMSID(cur->getname(),0));
if(p){
p->_entry+=cur->_entry;
p->_sum+=cur->_sum;
p->_sum2+=cur->_sum2;
p->_nsum2++;
cur->_entry=0;
if(cur->_min<p->_min)p->_min=cur->_min;
if(cur->_max>p->_max)p->_max=cur->_max;
}
}
}
else break;
}
}
dss_key * gen_dss_priv_key(unsigned int size) {
dss_key *key;
key = (dss_key*)m_malloc(sizeof(dss_key));
key->p = (mp_int*)m_malloc(sizeof(mp_int));
key->q = (mp_int*)m_malloc(sizeof(mp_int));
key->g = (mp_int*)m_malloc(sizeof(mp_int));
key->y = (mp_int*)m_malloc(sizeof(mp_int));
key->x = (mp_int*)m_malloc(sizeof(mp_int));
m_mp_init_multi(key->p, key->q, key->g, key->y, key->x, NULL);
seedrandom();
getq(key);
getp(key, size);
getg(key);
getx(key);
gety(key);
return key;
}
/* exe_one - execute one instruction */
void exe_one(void)
{
/* get the opcode */
opcode = getcbyte(pc); pc++;
/* execute the instruction */
switch (opcode) {
case OP_CALL:
*--sp = getboperand();
*--sp = pc;
*--sp = (int)(top - fp);
fp = sp;
pc = getafield(fp[fp[2]+3],A_CODE);
break;
case OP_SEND:
*--sp = getboperand();
*--sp = pc;
*--sp = (int)(top - fp);
fp = sp;
if (p2 = fp[fp[2]+3])
p2 = getofield(p2,O_CLASS);
else
p2 = fp[fp[2]+2];
if (p2 && (p2 = getp(p2,fp[fp[2]+1]))) {
pc = getafield(p2,A_CODE);
break;
}
*sp = NIL;
/* return NIL if there is no method for this message */
case OP_RETURN:
if (fp == top)
sts = CHAIN;
else {
p2 = *sp;
sp = fp;
fp = top - *sp++;
pc = *sp++;
p3 = *sp++;
sp += p3;
*sp = p2;
}
break;
case OP_TSPACE:
sp -= getboperand();
break;
case OP_TMP:
p2 = getboperand();
*sp = fp[-p2-1];
break;
case OP_TSET:
p2 = getboperand();
fp[-p2-1] = *sp;
break;
case OP_ARG:
p2 = getboperand();
if (p2 >= fp[2])
error("too few arguments");
*sp = fp[p2+3];
break;
case OP_ASET:
p2 = getboperand();
if (p2 >= fp[2])
error("too few arguments");
fp[p2+3] = *sp;
break;
case OP_BRT:
pc = (*sp ? getwoperand() : pc+2);
break;
case OP_BRF:
pc = (*sp ? pc+2 : getwoperand());
break;
case OP_BR:
pc = getwoperand();
break;
case OP_T:
*sp = T;
break;
case OP_NIL:
*sp = NIL;
break;
case OP_PUSH:
*--sp = NIL;
break;
case OP_NOT:
*sp = (*sp ? NIL : T);
break;
case OP_ADD:
p2 = *sp++;
*sp += p2;
break;
case OP_SUB:
p2 = *sp++;
*sp -= p2;
break;
case OP_MUL:
p2 = *sp++;
*sp *= p2;
break;
case OP_DIV:
p2 = *sp++;
*sp = (p2 == 0 ? 0 : *sp / p2);
break;
case OP_REM:
p2 = *sp++;
*sp = (p2 == 0 ? 0 : *sp % p2);
break;
case OP_BAND:
p2 = *sp++;
*sp &= p2;
break;
case OP_BOR:
p2 = *sp++;
*sp |= p2;
break;
case OP_BNOT:
*sp = ~*sp;
break;
case OP_LT:
p2 = *sp++;
*sp = (*sp < p2 ? T : NIL);
break;
case OP_EQ:
p2 = *sp++;
*sp = (*sp == p2 ? T : NIL);
break;
case OP_GT:
p2 = *sp++;
*sp = (*sp > p2 ? T : NIL);
break;
case OP_LIT:
*sp = getwoperand();
break;
case OP_SPLIT:
*sp = getboperand();
break;
case OP_SNLIT:
*sp = -getboperand();
break;
case OP_VAR:
*sp = getvalue(getwoperand());
break;
case OP_SVAR:
*sp = getvalue(getboperand());
break;
case OP_SET:
setvalue(getwoperand(),*sp);
break;
case OP_SSET:
setvalue(getboperand(),*sp);
break;
case OP_GETP:
p2 = *sp++;
*sp = getp(*sp,p2);
break;
case OP_SETP:
p3 = *sp++;
p2 = *sp++;
*sp = setp(*sp,p2,p3);
break;
case OP_PRINT:
print(*sp);
break;
case OP_PNUMBER:
pnumber(*sp);
break;
case OP_PNOUN:
show_noun(*sp);
break;
case OP_TERPRI:
trm_chr('\n');
break;
case OP_FINISH:
sts = FINISH;
break;
case OP_CHAIN:
sts = CHAIN;
break;
case OP_ABORT:
sts = ABORT;
break;
case OP_EXIT:
#ifdef MAC
macpause();
#endif
trm_done();
exit();
break;
case OP_YORN:
trm_get(line);
*sp = (line[0] == 'Y' || line[0] == 'y' ? T : NIL);
break;
case OP_CLASS:
*sp = getofield(*sp,O_CLASS);
break;
case OP_MATCH:
p2 = *sp++;
*sp = (match(*sp,nouns[p2-1],adjectives[p2-1]) ? T : NIL);
break;
case OP_SAVE:
*sp = db_save();
break;
case OP_RESTORE:
*sp = db_restore();
break;
case OP_RESTART:
*sp = db_restart();
break;
case OP_RAND:
*sp = getrand(*sp);
break;
case OP_RNDMIZE:
setrand(time(0L));
*sp = NIL;
break;
default:
if (opcode >= OP_XVAR && opcode < OP_XSET)
*sp = getvalue(opcode - OP_XVAR);
else if (opcode >= OP_XSET && opcode < OP_XPLIT)
setvalue(opcode - OP_XSET,*sp);
else if (opcode >= OP_XPLIT && opcode < OP_XNLIT)
*sp = opcode - OP_XPLIT;
else if (opcode >= OP_XNLIT && opcode < 256)
*sp = OP_XNLIT - opcode;
else
trm_str("Bad opcode\n");
break;
}
}
// INT 80h Handler, kernel entry.
void int_80() {
if(krn) {
return;
}
krn++;
int systemCall = kernel_buffer[0];
int fd = kernel_buffer[1];
int buffer = kernel_buffer[2];
int count = kernel_buffer[3];
int i, j;
Process * current;
Process * p;
int inode;
int _fd;
// Yeah, wanna know why we don't access an array directly? ... Because of big bugs we might have.
switch(systemCall) {
case READY:
kernel_buffer[KERNEL_RETURN] = kernel_ready();
break;
case WRITE:
current = getp();
kernel_buffer[KERNEL_RETURN] = fd_write(current->file_descriptors[fd],(char *)buffer,count);
break;
case READ:
current = getp();
kernel_buffer[KERNEL_RETURN] = fd_read(current->file_descriptors[fd],(char *)buffer,count);
break;
case MKFIFO:
_fd = process_getfreefd();
fd = fd_open(_FD_FIFO, (void *)kernel_buffer[1],kernel_buffer[2]);
if(_fd != -1 && fd != -1) {
getp()->file_descriptors[_fd] = fd;
kernel_buffer[KERNEL_RETURN] = _fd;
}
else {
kernel_buffer[KERNEL_RETURN] = -1;
}
break;
case OPEN:
_fd = process_getfreefd();
fd = fd_open(_FD_FILE, (void *) kernel_buffer[1], kernel_buffer[2]);
if(_fd != -1 && fd >= 0)
{
getp()->file_descriptors[_fd] = fd;
kernel_buffer[KERNEL_RETURN] = _fd;
}
else {
kernel_buffer[KERNEL_RETURN] = fd;
}
break;
case CLOSE:
kernel_buffer[KERNEL_RETURN] = fd_close(getp()->file_descriptors[fd]);
break;
case PCREATE:
kernel_buffer[KERNEL_RETURN] = sched_pcreate(kernel_buffer[1],kernel_buffer[2],kernel_buffer[3]);
break;
case PRUN:
kernel_buffer[KERNEL_RETURN] = sched_prun(kernel_buffer[1]);
break;
case PDUP2:
kernel_buffer[KERNEL_RETURN] = sched_pdup2(kernel_buffer[1],kernel_buffer[2],kernel_buffer[3]);
break;
case GETPID:
kernel_buffer[KERNEL_RETURN] = sched_getpid();
break;
case WAITPID:
kernel_buffer[KERNEL_RETURN] = sched_waitpid(kernel_buffer[1]);
break;
case PTICKS:
kernel_buffer[KERNEL_RETURN] = (int) storage_index();
break;
case PNAME:
p = process_getbypid(kernel_buffer[1]);
if(p == NULL)
{
kernel_buffer[KERNEL_RETURN] = (int) NULL;
} else {
kernel_buffer[KERNEL_RETURN] = (int) p->name;
}
break;
case PSTATUS:
p = process_getbypid(kernel_buffer[1]);
if(p == NULL)
{
kernel_buffer[KERNEL_RETURN] = (int) -1;
} else {
kernel_buffer[KERNEL_RETURN] = (int) p->state;
}
break;
case PPRIORITY:
p = process_getbypid(kernel_buffer[1]);
if(p == NULL)
{
kernel_buffer[KERNEL_RETURN] = (int) -1;
} else {
kernel_buffer[KERNEL_RETURN] = (int) p->priority;
}
break;
case PGID:
p = process_getbypid(kernel_buffer[1]);
if(p == NULL)
{
kernel_buffer[KERNEL_RETURN] = (int) -1;
} else {
kernel_buffer[KERNEL_RETURN] = (int) p->gid;
}
break;
case PGETPID_AT:
p = process_getbypindex(kernel_buffer[1]);
if (p->state != -1) {
kernel_buffer[KERNEL_RETURN] = (int) p->pid;
} else {
kernel_buffer[KERNEL_RETURN] = -1;
}
break;
case KILL:
kernel_buffer[KERNEL_RETURN - 1] = kernel_buffer[1];
kernel_buffer[KERNEL_RETURN - 2] = kernel_buffer[2];
break;
case PSETP:
p = process_getbypid(kernel_buffer[1]);
if(p == NULL) {
kernel_buffer[KERNEL_RETURN] = (int) -1;
} else {
if(kernel_buffer[2] <= 4 && kernel_buffer[2] >= 0) {
p->priority = kernel_buffer[2];
}
kernel_buffer[KERNEL_RETURN] = (int) p->gid;
}
break;
case SETSCHED:
sched_set_mode(kernel_buffer[1]);
break;
case PWD:
kernel_buffer[KERNEL_RETURN] = (int) fs_pwd();
break;
case CD:
kernel_buffer[KERNEL_RETURN] = (int) fs_cd(kernel_buffer[1]);
break;
case FINFO:
fs_finfo(kernel_buffer[1], kernel_buffer[2]);
break;
case MOUNT:
fs_init();
break;
case MKDIR:
kernel_buffer[KERNEL_RETURN] = (int) fs_mkdir(kernel_buffer[1],current_ttyc()->pwd);
break;
case RM:
inode = fs_indir(kernel_buffer[1],current_ttyc()->pwd);
if (inode) {
kernel_buffer[KERNEL_RETURN] = (int) fs_rm(inode,0);
} else {
kernel_buffer[KERNEL_RETURN] = ERR_NO_EXIST;
}
break;
case GETUID:
if(kernel_buffer[1] == 0)
{
kernel_buffer[KERNEL_RETURN] = (int) current_ttyc()->uid;
} else {
kernel_buffer[KERNEL_RETURN] = (int) user_exists(kernel_buffer[1]);
}
break;
case GETGID:
if(kernel_buffer[1] == 0)
{
kernel_buffer[KERNEL_RETURN] = (int) user_gid(current_ttyc()->uid);
} else {
kernel_buffer[KERNEL_RETURN] = (int) user_gid(kernel_buffer[1]);
}
break;
case MAKEUSER:
kernel_buffer[KERNEL_RETURN] = user_create(kernel_buffer[1],
kernel_buffer[2], user_gid(current_ttyc()->uid));
break;
case SETGID:
kernel_buffer[KERNEL_RETURN] = user_setgid(kernel_buffer[1],
kernel_buffer[2]);
break;
case UDELETE:
kernel_buffer[KERNEL_RETURN] = user_delete(kernel_buffer[1]);
break;
case UEXISTS:
kernel_buffer[KERNEL_RETURN] = user_exists(kernel_buffer[1]);
break;
case ULOGIN:
kernel_buffer[KERNEL_RETURN] = user_login(kernel_buffer[1],
kernel_buffer[2]);
break;
case ULOGOUT:
kernel_buffer[KERNEL_RETURN] = user_logout();
break;
case CHOWN:
kernel_buffer[KERNEL_RETURN] = fs_chown(kernel_buffer[1],
kernel_buffer[2]);
break;
case CHMOD:
kernel_buffer[KERNEL_RETURN] = fs_chmod(kernel_buffer[1],
kernel_buffer[2]);
break;
case GETOWN:
kernel_buffer[KERNEL_RETURN] = fs_getown(kernel_buffer[1]);
break;
case GETMOD:
kernel_buffer[KERNEL_RETURN] = fs_getmod(kernel_buffer[1]);
break;
case CP:
kernel_buffer[KERNEL_RETURN] = fs_cp(kernel_buffer[1], kernel_buffer[2], current_ttyc()->pwd, current_ttyc()->pwd);
break;
case MV:
kernel_buffer[KERNEL_RETURN] = fs_mv(kernel_buffer[1], kernel_buffer[2], current_ttyc()->pwd);
break;
case LINK:
kernel_buffer[KERNEL_RETURN] = fs_open_link(kernel_buffer[1], kernel_buffer[2], current_ttyc()->pwd);
break;
case FSSTAT:
kernel_buffer[KERNEL_RETURN] = fs_stat(kernel_buffer[1]);
break;
case SLEEP:
kernel_buffer[KERNEL_RETURN] = scheduler_sleep(kernel_buffer[1]);
break;
default:
break;
}
krn--;
}
int main() {
int i,j,row,col;
int soln[200],min,mark,pre[50][200];
// freopen("in.txt","r",stdin);
while(scanf("%d %d",&row,&col)==2) {
for(i=1; i<=row; i++) {
for(j=1; j<=col; j++) {
scanf("%d",&matrix[i][j]);
}
}
if(row==1) {
min=0;
for(j=1; j<=col; j++) {
soln[j]=1;
min+=matrix[1][j];
}
for(j=1; j<col; j++) {
printf("%d ",soln[j]);
}
printf("%d\n",soln[col]);
printf("%d\n",min);
}
else if(col==1) {
min=matrix[1][1];
mark=1;
for(i=1; i<=row; i++) {
if(matrix[i][1]<min) {
min=matrix[i][1];
mark=i;
}
}
soln[1]=mark;
printf("%d\n",soln[1]);
printf("%d\n",min);
}
else {
for(j=col-1; j>=1; j--) {
for(i=1; i<=row; i++) {
if(i==1) {
matrix[i][j]+=max(matrix[row][j+1],matrix[i][j+1],matrix[i+1][j+1]);
pre[i][j]=getp1(matrix[i][j+1],matrix[i+1][j+1],matrix[row][j+1]);
}
else if(i==row) {
matrix[i][j]+=max(matrix[1][j+1],matrix[i][j+1],matrix[i-1][j+1]);
pre[i][j]=getp2(matrix[1][j+1],matrix[i-1][j+1],matrix[i][j+1]);
}
else {
matrix[i][j]+=max(matrix[i-1][j+1],matrix[i][j+1],matrix[i+1][j+1]);
pre[i][j]=getp(matrix[i-1][j+1],matrix[i][j+1],matrix[i+1][j+1]);
}
}
}
min=matrix[1][1];
mark=1;
for(i=1; i<=row; i++) {
if(matrix[i][1]<min) {
min=matrix[i][1];
mark=i;
}
}
soln[1]=mark;
for(j=1; j<col; j++) {
if(pre[mark][j]==2) {
mark=mark;
}
else if(pre[mark][j]==1) {
mark--;
if(mark<1) mark=row;
}
else if(pre[mark][j]==3) {
mark++;
if(mark>row) mark=1;
}
soln[j+1]=mark;
}
for(i=1; i<col; i++) {
printf("%d ",soln[i]);
}
printf("%d\n",soln[col]);
printf("%d\n",min);
}
}
return 0;
}
void addedge(int&a,int&b,int f){getp(a);getp(b);ins(a,b,f);ins(b,a,0);}
static int baleful_op(RAnal *anal, RAnalOp *op, ut64 addr, const ut8 *buf, int len) {
const ut8 *r = 0;
const ut8 *r0 = 0;
const ut8 *r1 = 0;
const ut8 *p = 0;
const ut32 *imm = 0;
const ut32 *imm1 = 0;
const ut8 p0[16];
const ut8 p1[16];
const ut8 p2[16];
const ut8 p3[16];
if (op == NULL)
return 1;
memset (op, 0, sizeof (RAnalOp));
op->type = R_ANAL_OP_TYPE_NULL;
op->delay = 0;
op->jump = op->fail = -1;
op->ptr = op->val = -1;
op->refptr = 0;
r_strbuf_init (&op->esil);
switch (buf[0]) {
case 2: // 8 8 11 5 ADD +
op->type = R_ANAL_OP_TYPE_ADD;
op->size = getp(buf,p0,p1,p2,p3,0);
r_strbuf_setf (&op->esil, "%s,%s,+,%s,=",p2,p1,p0);
break;
case 3: // 8 8 11 5 SUB -
op->type = R_ANAL_OP_TYPE_SUB;
op->size = getp(buf,p0,p1,p2,p3,0);
r_strbuf_setf (&op->esil, "%s,%s,-,%s,=",p2,p1,p0);
break;
case 4: // 8 8 11 5 MUL *
op->type = R_ANAL_OP_TYPE_MUL;
op->size = getp(buf,p0,p1,p2,p3,0);
r_strbuf_setf (&op->esil, "%s,%s,*,%s,=",p2,p1,p0);
break;
case 6: // 8 8 11 5 XOR ^
op->type = R_ANAL_OP_TYPE_XOR;
op->size = getp(buf,p0,p1,p2,p3,0);
r_strbuf_setf (&op->esil, "%s,%s,^,%s,=",p2,p1,p0);
break;
case 9: // 8 8 11 5 AND &
op->type = R_ANAL_OP_TYPE_AND;
op->size = getp(buf,p0,p1,p2,p3,0);
r_strbuf_setf (&op->esil, "%s,%s,&,%s,=",p2,p1,p0);
break;
case 10: // 8 8 11 5 OR |
op->type = R_ANAL_OP_TYPE_OR;
op->size = getp(buf,p0,p1,p2,p3,0);
r_strbuf_setf (&op->esil, "%s,%s,|,%s,=",p2,p1,p0);
break;
case 12: // 8 8 11 5 ROL <<<<
op->type = R_ANAL_OP_TYPE_ROL;
op->size = getp(buf,p0,p1,p2,p3,0);
r_strbuf_setf (&op->esil, "%s,%s,<<<<,%s,=",p2,p1,p0);
break;
case 13: // 8 8 11 5 ROR >>>>
op->type = R_ANAL_OP_TYPE_ROR;
op->size = getp(buf,p0,p1,p2,p3,0);
r_strbuf_setf (&op->esil, "%s,%s,>>>>,%s,=",p2,p1,p0);
break;
case 25: // ++
op->type = R_ANAL_OP_TYPE_ADD;
op->size = getp(buf,p0,p1,p2,p3,6);
r_strbuf_setf (&op->esil, "%s,++,=",p1);
break;
case 26: // --
op->type = R_ANAL_OP_TYPE_SUB;
op->size = getp(buf,p0,p1,p2,p3,6);
r_strbuf_setf (&op->esil, "%s,--,=",p1);
break;
////////////////////////////////////////// SPECIAL DIV/MOD ////////////////////////////////
case 5: // 9 9 12 6 DIV
op->type = R_ANAL_OP_TYPE_DIV;
op->size = getp(buf,p0,p1,p2,p3,1);
r_strbuf_setf (&op->esil, "%s,%s,/,%s,=,%s,%s,%%,%s,=",p2,p1,p0,p2,p1,p3);
break;
////////////////////////////////// MOVS ///////////////////////////////////////////////////
case 24: //7 4 MOV
op->type = R_ANAL_OP_TYPE_MOV;
op->size = getp(buf,p0,p1,p2,p3,3);
r_strbuf_setf (&op->esil, "%s,%s,=",p2,p1);
break;
case 27: // MOV r,[r]
r = buf + 1;
r1 = buf + 2;
op->type = R_ANAL_OP_TYPE_MOV;
op->size = 3;
r_strbuf_setf (&op->esil, "r_%02x,[4],r_%02x,=",*r1,*r);
break;
case 28:// MOV [r],r1
r = buf + 1;
r1 = buf + 2;
op->type = R_ANAL_OP_TYPE_MOV;
op->size = 3;
r_strbuf_setf (&op->esil, "r_%02x,r_%02x,=[4]",*r1,*r);
break;
///////////////////////////////// JUMPS /////////////////////////////////////////////////
case 14: //5 JMP
imm = (ut32 *)(buf + 1);
op->type = R_ANAL_OP_TYPE_JMP;
op->size = getp(buf,p0,p1,p2,p3,5);
r_strbuf_setf(&op->esil,"%s,pc,=",p1);
break;
case 16: //5 JZ
op->type = R_ANAL_OP_TYPE_CJMP;
op->size = getp(buf,p0,p1,p2,p3,5);
r_strbuf_setf(&op->esil, "zf,?{,%s,pc,=,}",p1);
break;
case 21: //5 JNZ
op->type = R_ANAL_OP_TYPE_CJMP;
op->size = getp(buf,p0,p1,p2,p3,5);
r_strbuf_setf(&op->esil, "zf,!,?{,%s,pc,=,}",p1);
break;
case 17: //5 JS
op->type = R_ANAL_OP_TYPE_CJMP;
op->size = getp(buf,p0,p1,p2,p3,5);
r_strbuf_setf(&op->esil, "sf,?{,%s,pc,=,}",p1);
break;
case 20: //5 JNS
op->type = R_ANAL_OP_TYPE_CJMP;
op->size = getp(buf,p0,p1,p2,p3,5);
r_strbuf_setf(&op->esil, "sf,!,?{,%s,pc,=,}",p1);
break;
case 19: //5 JG
op->type = R_ANAL_OP_TYPE_CJMP;
op->size = getp(buf,p0,p1,p2,p3,5);
r_strbuf_setf(&op->esil, "gf,?{,%s,pc,=,}",p1);
break;
case 18: //5 JBE
op->type = R_ANAL_OP_TYPE_CJMP;
op->size = getp(buf,p0,p1,p2,p3,5);
r_strbuf_setf(&op->esil, "gf,!,?{,%s,pc,=,}",p1);
break;
//////////////////////////////// EFLAGS WRITER ///////////////////////////////////////////////////////////
// http://www.read.seas.harvard.edu/~kohler/class/aosref/i386/appc.htm
//http://sourceforge.net/p/fake86/code/ci/master/tree/src/fake86/cpu.c
case 22: // 7 7 10 4 AND
op->type = R_ANAL_OP_TYPE_AND;
op->size = getp(buf,p0,p1,p2,p3,2);
break;
case 23: // 7 7 10 4 CMP
op->type = R_ANAL_OP_TYPE_SUB;
op->size = getp(buf,p0,p1,p2,p3,2);
r_strbuf_setf(&op->esil,"0,sf,=,%s,%s,<,sf,=,0,zf,=,%s,%s,==,%%z,zf,=,0,gf,=,%s,%s,>,gf,=",p1,p2,p1,p2,p1,p2);
//"0,sf,=,%s,%s,<,sf,=" //SF
//"0,zf,=,%s,%s,==,%%z,zf,=" //ZF
//"0,gf,=,%s,%s,>,gf,=" //GF
break;
/////////////////////////////////////// STACK ////////////////////////////////////////////////////////////
case 30: //6 3 PUSH
p = buf + 1;
op->type = R_ANAL_OP_TYPE_PUSH;
op->size = getp(buf,p0,p1,p2,p3,4);
r_strbuf_setf(&op->esil,"%s,stk,=[4],4,stk,+=",p1);
break;
case 31: // POP
op->type = R_ANAL_OP_TYPE_POP;
op->size = getp(buf,p0,p1,p2,p3,6);
r_strbuf_setf(&op->esil,"4,stk,-=,stk,[4],%s,=",p1);
break;
case 15: //5 CALL
imm = (ut32 *)(buf + 1);
op->type = R_ANAL_OP_TYPE_CALL;
op->size = getp(buf,p0,p1,p2,p3,5);
r_strbuf_setf(&op->esil,"%04x,pc,+,stk,=[4],4,stk,+=,%s,pc,=",op->size,p1);
break;
case 1: // RET
op->type = R_ANAL_OP_TYPE_RET;
op->size = 1;
r_strbuf_setf(&op->esil,"4,stk,-=,stk,[4],pc,=");
break;
///////////////////////////////////////////////////////////////////////////////////////////////////////////
case 11:
r_strbuf_setf (&op->esil, "regX = regY==0");
op->size = 3;
break;
case 7:
r_strbuf_setf (&op->esil, "regX = NEG regY");
op->size = 3;
break;
case 8:
r_strbuf_setf (&op->esil, "regX = NOT regY");
op->size = 3;
break;
///////////////////////////////////////////////////////////////////////////////////////////////////////////
case 32: // SYSCALL
p = buf + 1;
op->type = R_ANAL_OP_TYPE_CALL;
op->size = 2;
r_strbuf_setf (&op->esil, "%x,$",*p);
/*if (*p==0)
r_strbuf_setf (&op->esil, "apicall: putchar()");
else
r_strbuf_setf (&op->esil, "apicall: %02x",*p);*/
break;
case 29:// VMEND
op->type = R_ANAL_OP_TYPE_NOP;
op->size = 1;
r_strbuf_setf (&op->esil, "end virtual");
break;
case 0:// NOP
default:
op->type = R_ANAL_OP_TYPE_NOP;
op->size = 1;
r_strbuf_setf (&op->esil, "nop");
break;
}
return op->size;
}
bool SMDBExecutor::execute(Cmd& cmd)
{
const char* key = cmd[0].c_str();
if(0 == strcasecmp("select", key))
{
CheckParam(3);
return SMDBInterface::Select(getp(1),getp(2), atoi(getp(3)));
}
else if(0 == strcasecmp("update", key))
{
CheckParam(3);
return SMDBInterface::Update(getp(1),getp(2), getp(3));
}
else if(0 == strcasecmp("insert", key))
{
CheckParam(3);
return SMDBInterface::Insert(getp(1),getp(2), getp(3));
}
else if(0 == strcasecmp("delete", key))
{
CheckParam(2);
return SMDBInterface::Delete(getp(1),getp(2));
}
else if(0 == strcasecmp("memsql", key))
{
CheckParam(2);
return SMDBInterface::Memsql(getp(1),getp(2));
}
return false;
}
int main(void)
{
/* request auto detection */
int gdriver = DETECT, gmode, errorcode;
int xmax, ymax;
int xs[]={200,100,250,350,300,270};
int ys[]={400,200,50,170,350,280};
int n=sizeof(xs)/sizeof(*xs);
int i=0,j=0;
float inverse_m[6];
struct point *points[6];
struct point *sortedy[6];
struct point *sortedx[6];
struct edge *edges[6];
float p=0;
for(i=0;i<n;i++)
{
points[i]=(struct point *)malloc(sizeof(struct point));
points[i]->x=xs[i];
points[i]->y=ys[i];
}
initgraph(&gdriver, &gmode, "C:\\Turboc3\\BGI");
errorcode = graphresult();
if (errorcode != grOk)
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1);
}
setcolor(getmaxcolor());
for(i=0;i<n;i++)
{
if(i==(n-1))
{
line(xs[i],ys[i],xs[0],ys[0]);
}
else
{
line(xs[i],ys[i],xs[i+1],ys[i+1]);
}
}
printf("%d\n",n);
for(i=0;i<n;i++)
{
if(i==(n-1))
{
inverse_m[i]=(xs[i]-xs[0])/((float)(ys[i]-ys[0]));
}
else
{
inverse_m[i]=(xs[i]-xs[i+1])/((float)(ys[i]-ys[i+1]));
}
}
for(i=0;i<n;i++)
{
printf("%d , %d\n",points[i]->x,points[i]->y);
}
for(i=0;i<n;i++)
{
edges[i]=(struct edge *)malloc(sizeof(struct edge));
edges[i]->start=points[i];
if(i==n-1)
{
edges[i]->end=points[0];
}
else
{
edges[i]->end=points[i+1];
}
edges[i]->inv_m=inverse_m[i];
if((edges[i]->end->x)>(edges[i]->start->x))
{
edges[i]->xmin=edges[i]->start->x;
}
else
{
edges[i]->xmin=edges[i]->end->x;
}
if((edges[i]->end->y)>(edges[i]->start->y))
{
edges[i]->ymin=edges[i]->start->y;
edges[i]->xymin=edges[i]->start->x;
}
else
{
edges[i]->ymin=edges[i]->end->y;
edges[i]->xymin=edges[i]->end->x;
}
edges[i]->status=0;
}
for(i=0;i<n;i++)
{
struct edge *first=edges[i];
struct edge *second;
if(i==n-1)
{
second=edges[0];
}
else
{
second=edges[i+1];
}
if(first->start->y>first->end->y && second->end->y<second->start->y)
{
struct point *temp=(struct point*)malloc(sizeof(struct point));
temp->y=second->start->y+1;
p=getp(first->end->x,first->end->y,first->start->x,first->start->y);
if(p>0)
{
if(first->end->x>first->start->x)
{
temp->x=first->end->x-1;
}
else
{
temp->x=first->end->x+1;
}
}
else
{
temp->x=first->end->x;
}
first->end=temp;
}
else if(first->start->y<first->end->y && second->end->y>second->start->y)
{
struct point *temp=(struct point*)malloc(sizeof(struct point));
temp->y=first->end->y+1;
p=getp(second->start->x,second->start->y,second->end->x,second->end->y);
if(p>0)
{
if(second->end->x>second->start->x)
{
temp->x=second->start->x+1;
}
else
{
temp->x=second->start->x-1;
}
}
else
{
temp->x=second->start->x;
}
second->start=temp;
}
}
for(i=0;i<n-1;i++)
{
for(j=0;j<n-i-1;j++)
{
if(edges[j]->ymin>edges[j+1]->ymin)
{
struct edge *temp=edges[j];
edges[j]=edges[j+1];
edges[j+1]=temp;
}
else if(edges[j]->ymin==edges[j+1]->ymin)
{
if(edges[j]->xmin>edges[j+1]->xmin)
{
struct edge *temp=edges[j];
edges[j]=edges[j+1];
edges[j+1]=temp;
}
}
}
}
for(i=0;i<n;i++)
{
printf("startx=%d , starty=%d endx=%d , endy=%d xmin=%d , ymin=%d xymin=%d \n ",edges[i]->start->x,edges[i]->start->y,edges[i]->end->x,edges[i]->end->y,edges[i]->xmin,edges[i]->ymin,edges[i]->xymin);
}
getch();
closegraph();
return 0;
}
void Decrypt(PK0304 *le, char *password)
{
char *salt, *key1, *key2, *check, digest[40];
u32 key_len, dig_len = 40, start, xlen;
AE_EXTRA ae;
start = ftell(ZIN);
/* Searches for AE-1 header */
fseek(ZIN, le->NameLen, SEEK_CUR);
for(xlen=le->ExtraLen; xlen;)
{
safeRead(&ae, ZIN, 4);
xlen -= (4 + ae.Size);
if (ae.Sig == 0x9901)
{
safeRead(&ae.Version, ZIN, 7);
continue;
}
fseek(ZIN, ae.Size, SEEK_CUR);
}
if (ae.Sig != 0x9901)
Z_ERROR("Fatal! Can't find AE extra header!");
if (ae.Strength < 1 || ae.Strength > 3)
Z_ERROR("Bad encryption strength");
SaltSize = KS[ae.Strength].Salt;
KeySize = KS[ae.Strength].Key;
salt = BUF;
key1 = salt+SaltSize;
key2 = key1+KeySize;
check = key2+KeySize;
key_len = KeySize*2+2;
/* Loads salt and password check value, and regenerates original crypto material */
fseek(ZIN, start+le->NameLen+le->ExtraLen, SEEK_SET);
safeRead(salt, ZIN, SaltSize);
safeRead(check+2, ZIN, 2);
point1:
if (pkcs_5_alg2(password, strlen(password), salt, SaltSize, 1000, 0, key1, &key_len) != CRYPT_OK)
Z_ERROR("Failed to derive encryption keys");
if (memcmp(check, check+2, 2))
{
printf("\nCan't decrypt data: try another password.\nNew password: "******"\n");
goto point1;
}
if (ctr_start(0, IV, key1, KeySize, 0, CTR_COUNTER_LITTLE_ENDIAN, &ctr) != CRYPT_OK)
Z_ERROR("Failed to setup AES CTR decoder");
#ifdef GLADMAN_HMAC
hmac_sha1_begin(&hmac);
hmac_sha1_key(key2, KeySize, &hmac);
#else
if (hmac_init(&hmac, 0, key2, KeySize) != CRYPT_OK)
Z_ERROR("Failed to setup HMAC-SHA1");
#endif
/* Adjusts local header */
le->Flag ^= 1;
le->CompMethod = ae.CompMethod;
le->ExtraLen -= 11;
le->CompSize -= (SaltSize + 12);
/* Writes local header and copies extra, except 0x9901 */
safeWrite(ZOUT, le, sizeof(PK0304));
fseek(ZIN, start, SEEK_SET);
fileCopy(ZOUT, ZIN, le->NameLen);
for(xlen=le->ExtraLen+11; xlen;)
{
safeRead(&ae, ZIN, 4);
xlen -= (4 + ae.Size);
if (ae.Sig == 0x9901)
{
safeRead(&ae.Version, ZIN, 7);
continue;
}
safeWrite(ZOUT, &ae, 4);
fileCopy(ZOUT, ZIN, ae.Size);
}
fseek(ZIN, SaltSize+2, SEEK_CUR);
fileFilter(ZOUT, ZIN, le->CompSize);
#ifdef GLADMAN_HMAC
hmac_sha1_end(digest, dig_len, &hmac);
#else
if (hmac_done(&hmac, digest, &dig_len) != CRYPT_OK)
Z_ERROR("Failed to computate HMAC");
#endif
/* Retrieves and checks HMACs */
safeRead(digest+10, ZIN, 10);
if (memcmp(digest, digest+10, 10))
printf(" authentication failed, contents were lost!");
ctr_done(&ctr);
}
int getp(int i) {
return i == p[i] ? i : (p[i] = getp(p[i]));
}
bool setp(int i, int j) {
i = getp(i);
j = getp(j);
p[i] = j;
return i != j;
}
int main(int argc,char** argv)
{
char pm, operation=-1, found=1, pw1[128], pw2[128], ae1[15], ae2[15];
u32 i;
PK0102 ce;
PK0304 le;
PK0506 ed;
for (pm=1; pm < argc; pm++)
{
char opt;
if (argv[pm][0] != '/') continue;
if (argv[pm][1] == '?') {
printf( "Encrypts or decrypts an archive following WinZip(R) 9 specifications.\n\n" \
"ZAES /D | /E:keysize [/2] archive.zip\n\n" \
" /D decrypts AES encrypted entries\n" \
" /E:keysize encrypts with 128, 192 or 256-bit keys (keysize 1, 2 or 3)\n" \
" /2 AE-2 format (sets CRC-32 to zero)\n");
return 1;
}
opt = toupper(argv[pm][1]);
if (opt== 'E') {
Mode = atol(&argv[pm][3]);
operation = 0;
filter = encrypt_authenticate;
if (Mode < 1 || Mode > 3)
Z_ERROR("Bad encryption mode specified!");
SaltSize = KS[Mode].Salt;
KeySize = KS[Mode].Key;
found++;
continue;
}
if (opt== 'D') {
operation = 1;
filter = authenticate_decrypt;
found++;
continue;
}
if (opt== '2') {
AE2 = 1;
found++;
printf("WARNING: according to AE-2 specifications, CRC-32 will be set to zero\n"\
"in encrypted entries. Reverting to original archive after decryption will\n"\
"be impossible with this utility!\n");
continue;
}
}
argv+=found;
argc-=found;
if (operation == -1) Z_ERROR("You must specify /E or /D switch!\nTry ZAES /?");
if (argc < 1) Z_ERROR("You must give a ZIP archive to process!");
register_prng(&sprng_desc);
register_cipher(&aes_desc);
register_hash(&sha1_desc);
//~ printf("DEBUG: sha1 id=%d, aes id=%d\n", find_hash("sha1"), find_cipher("aes"));
if ( (ZIN=fopen(argv[0],"rb")) == 0 || (ZIN2=fopen(argv[0],"rb")) == 0 )
Z_ERROR("Can't open input ZIP archive");
if ( (ZOUT=topen(ae1)) == 0 || (ZTMP=topen(ae2)) == 0)
Z_ERROR("Can't open temporary output files");
setvbuf(ZIN , 0, _IOFBF, BLOCK);
setvbuf(ZOUT, 0, _IOFBF, BLOCK);
/* assumiamo uno ZIP senza commento! */
fseek(ZIN2,-22,SEEK_END);
safeRead(&ed, ZIN2, sizeof(PK0506));
if (ed.Sig != 0x06054B50)
#ifdef HANDLE_COMMENT
{
fseek(ZIN2, -0xFFFF, SEEK_END);
fread(p, 1, 4, ZIN2);
#else
Z_ERROR("End directory marker not found!");
#endif
/* verifica un minimo di coerenza nella ENDDIR */
if (ed.Disk != 0)
Z_ERROR("Can't process a spanned archive");
while(1) {
printf("Enter password: "******"\rFor your safety, please use a password of 8 characters or more.\n");
continue;
}
if (operation) {
printf("\n");
break;
}
printf("\rVerify password: "******"Passwords don't match!\n");
continue;
}
printf("\n");
break;
}
#define PUTN(x) { fileCopy(stdout, ZIN, x.NameLen); fseek(ZIN, -x.NameLen, SEEK_CUR); }
fseek(ZIN2, ed.Offset, SEEK_SET);
for (i=0; i < ed.Total; i++)
{
safeRead(&ce, ZIN2, sizeof(PK0102));
if (ce.Sig != 0x02014B50)
Z_ERROR("Expected central directory marker not found");
/* Assume i dati corretti dalla LE */
fseek(ZIN, ce.Offset, SEEK_SET);
safeRead(&le, ZIN, sizeof(PK0304));
if (le.Sig != 0x04034B50)
Z_ERROR("Expected local entry marker not found");
if ( ((le.Flag & 1) && !operation) || /* doesn't encrypt already encrypted */
(!(le.Flag & 1) && operation) || /* doesn't decrypt already decrypted */
((le.Flag & 1) && operation && le.CompMethod != 99) || /* doesn't decrypt not AES encrypted */
!le.CompSize )
{
ce.Offset = ftell(ZOUT);
safeWrite(ZOUT, &le, sizeof(PK0304));
printf(" copying: "); PUTN(le);
fileCopy(ZOUT, ZIN, le.NameLen+le.ExtraLen+le.CompSize);
printf("\n");
safeWrite(ZTMP, &ce, sizeof(PK0102));
fileCopy(ZTMP, ZIN2, ce.NameLen+ce.ExtraLen);
continue;
}
if (!operation)
{
AE_EXTRA ae = {0x9901, 7, AE2+1, 0x4541, Mode, 0};
ae.CompMethod = ce.CompMethod;
ce.CompMethod = 99;
if (AE2) ce.Crc32 = 0;
ce.Flag |= 1;
ce.ExtraLen += 11;
ce.CompSize += SaltSize + 12; /* variable salt, fixed password check and hmac */
ce.Offset = ftell(ZOUT);
safeWrite(ZTMP, &ce, sizeof(PK0102));
fileCopy(ZTMP, ZIN2, ce.NameLen+ce.ExtraLen-11);
safeWrite(ZTMP, &ae, 11);
printf(" encrypting: "); PUTN(le);
Encrypt(&le, &ae, pw1);
printf("\n");
}
else
{
ce.Offset = ftell(ZOUT);
printf(" decrypting: "); PUTN(le);
Decrypt(&le, pw1); /* Decrypts contents */
printf("\n");
ce.CompMethod = le.CompMethod;
if (AE2) ce.Crc32 = 0;
ce.Flag ^= 1;
ce.ExtraLen -= 11;
ce.CompSize = le.CompSize;
safeWrite(ZTMP, &ce, sizeof(PK0102));
/* Copy the extra data (may be LE != CE) */
fileCopy(ZTMP, ZIN2, ce.NameLen);
for(ce.ExtraLen+=11; ce.ExtraLen;)
{
u16 u[2];
safeRead(u, ZIN2, 4);
ce.ExtraLen -= (4 + u[1]);
if (u[0] == 0x9901)
{
fseek(ZIN2, u[1], SEEK_CUR);
continue;
}
safeWrite(ZTMP, u, 4);
fileCopy(ZTMP, ZIN2, u[1]);
}
}
}
ed.Offset = ftell(ZOUT); /* new central directory start */
ed.Size = ftell(ZTMP); /* new central directory size */
fseek(ZTMP, 0, SEEK_SET);
fclose(ZIN);
fclose(ZIN2);
/* Copies central directory */
fileCopy(ZOUT, ZTMP, ed.Size);
safeWrite(ZOUT, &ed, sizeof(PK0506));
fclose(ZTMP);
fclose(ZOUT);
remove(ae2);
if (remove(argv[0]))
{
printf("Can't remove old archive; new one is in file '%s'\n", ae1);
} else
if (rename(ae1, argv[0]))
{
printf("Can't rename old archive; new one is in file '%s'\n", ae1);
}
memset(&BUF, 0, sizeof(BUF));
memset(&ctr, 0, sizeof(ctr));
memset(pw1, 0, 128);
memset(pw2, 0, 128);
return 0;
}
