Beispiel #1
0
static int
IsDATNewer (char *IniFile, char *DatFile)
{
  int ihandle, dhandle, result;
  struct ftime itime, dtime;

  ihandle = open (IniFile, O_RDONLY);
  if (ihandle == -1)
    return FALSE;

  dhandle = open (DatFile, O_RDONLY);
  if (dhandle == -1)
    {
      close (ihandle);
      return FALSE;
    }

  if (getftime (ihandle, &itime) == -1)
    return CloseFiles (ihandle, dhandle);
  if (getftime (dhandle, &dtime) == -1)
    return CloseFiles (ihandle, dhandle);

  if (dtime.ft_year > itime.ft_year)
    result = TRUE;
  else if (dtime.ft_year < itime.ft_year)
    result = FALSE;
  else if (dtime.ft_month > itime.ft_month)
    result = TRUE;
  else if (dtime.ft_month < itime.ft_month)
    result = FALSE;
  else if (dtime.ft_day > itime.ft_day)
    result = TRUE;
  else if (dtime.ft_day < itime.ft_day)
    result = FALSE;
  else if (dtime.ft_hour > itime.ft_hour)
    result = TRUE;
  else if (dtime.ft_hour < itime.ft_hour)
    result = FALSE;
  else if (dtime.ft_min > itime.ft_min)
    result = TRUE;
  else if (dtime.ft_min < itime.ft_min)
    result = FALSE;
  else if (dtime.ft_tsec > itime.ft_tsec)
    result = TRUE;
  else
    result = FALSE;

  CloseFiles (ihandle, dhandle);
  return result;
}
Beispiel #2
0
void truncate(char *fname)
{
#ifdef __TURBOC__
            struct ftime Ftime;
#else
            unsigned short date, time;
#endif

            fd = open(fname, O_WRONLY);

#ifdef __TURBOC__                         /* Save the time/date         */
            getftime(fd, &Ftime);
#else
            GETFTIME(fd, (FTIME_T *)&date, (FTIME_T *)&time);
#endif

            chsize(fd, 0L);               /* Truncate the file          */

#ifdef __TURBOC__                         /* Restore the time/date      */
            setftime(fd, &Ftime);
#else
            SETFTIME(fd, (FTIME_T)date, (FTIME_T)time);
#endif
            close(fd);
}
int check_filetime(const char *fn, FILETIME *ft)
{
	FILETIME t0;
	if (getftime (fn, &t0) && CompareFileTime(&t0, ft) > 0)
	{
		*ft = t0;
		return TRUE;
	}
	return FALSE;
}
Beispiel #4
0
int main(
    int argc,
    char **argv )
{
    glutInit( &argc, argv );
    glutInitWindowSize( 600, 600 );
    /* glutInitDisplayMode must be called before glutCreateWindow, flags are prefixed with GLUT_ not GL */
    glutInitDisplayMode( GLUT_RGBA | GLUT_DEPTH | GLUT_DOUBLE );
    glutCreateWindow( "Depth Buffer" );
    glutDisplayFunc( display );
    /* register glutPostRedisplay for continuous animation */
    glutIdleFunc(glutPostRedisplay);

    lasttime = getftime();
    glutMainLoop(  );
}
Beispiel #5
0
void display(
    void )
{
    int width, height;
    double finishtime, delta_t;

    static float angle = 0;

    width = glutGet(GLUT_WINDOW_WIDTH);
    height = glutGet(GLUT_WINDOW_HEIGHT);

    glClearColor( 0.5, 0.5, 0.5, 1.0 );
    /* combine the clearing flags for more efficient operation */
    glClear( GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT );

    glViewport(0, 0, width, height);

    glMatrixMode( GL_PROJECTION );
    glLoadIdentity();
    gluPerspective( 90, (float)width/(float)height, 1, 12 );

    glMatrixMode( GL_MODELVIEW );
    glLoadIdentity();
    gluLookAt( 0, 4, 4, 0, 0, 0, 0, 1, 0 );

    glEnable( GL_DEPTH_TEST );

    glRotated( angle, 1, 0, 0 );
    glColor3f( 1, 0, 0 );
    glutSolidSphere( 1, 20, 20 );
    glColor3f( 0.8, 0.8, 0 );
    glutWireSphere( 1, 20, 20 );
    glColor3f( 0, 0, 1 );
    glutSolidTorus( 1, 2, 40, 40 );
    glDisable( GL_DEPTH_TEST );

    glutSwapBuffers();

    finishtime = getftime();
    delta_t = finishtime - lasttime;

    angle = fmodf(angle + 10*delta_t, 360);

    lasttime = finishtime;
}
int main(int argc, char *argv[])
{
      int fd0, fd1;

#ifdef __TURBOC__
      struct ftime Ftime;
#else
      unsigned date, time;
#endif

      if (3 > argc)
      {
            puts("Usage: SETIMETO old_filename new_filename");
            return EXIT_FAILURE;
      }

      if (-1 == (fd0 = open(argv[1], O_RDONLY)))
      {
            printf("Unable to open %s\n", argv[1]);
            return EXIT_FAILURE;
      }

#ifdef __TURBOC__                         /* Save the time/date         */
      getftime(fd0, &Ftime);
#else
      GETFTIME(fd0, &date, &time);
#endif

      if (-1 == (fd1 = open(argv[2], O_WRONLY)))
      {
            printf("Unable to open %s\n", argv[2]);
            return EXIT_FAILURE;
      }

#ifdef __TURBOC__                         /* Set the time/date          */
      setftime(fd1, &Ftime);
#else
      SETFTIME(fd1, date, time);
#endif

      close(fd0);
      close(fd1);
      return EXIT_SUCCESS;
}
void copydate(const char *srcfile, const char *dstfile) {
	int srchandle=open(srcfile,O_RDONLY);
	if(srchandle<0) {
		fprintf(stderr,"%s: could not open %s\n",PROGNAME,srcfile);
		exit(5);
	}
	struct ftime dt;
	if(getftime(srchandle,&dt)) {
		fprintf(stderr,"%s: could get date of %s\n",PROGNAME,srcfile);
		exit(5);
	}
	close(srchandle);

	int dsthandle=open(dstfile,O_RDONLY);
	if(srchandle<0) {
		fprintf(stderr,"%s: could not open %s\n",PROGNAME,dstfile);
		exit(5);
	}
	if(setftime(dsthandle,&dt)) {
		fprintf(stderr,"%s: could set date of %s\n",PROGNAME,dstfile);
		exit(5);
	}
	close(dsthandle);
}
Beispiel #8
0
long FName::TimeStamp()
{
#ifdef WIN32
    HANDLE f=CreateFile(Str,GENERIC_READ,0,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);
    if (f==INVALID_HANDLE_VALUE) return -1;
    FILETIME ft;
    GetFileTime(f,NULL,NULL,&ft);
    WORD Date,Time;
    FileTimeToDosDateTime(&ft,&Date,&Time);
    CloseHandle(f);
    return Time+(Date<<16);
#else
    int hand;
    union Time
    {
        ftime ft;
        unsigned long dw;
    } ft;
    if ((hand=open(Str,O_RDONLY))<0) return -1;
    getftime(hand,&ft.ft);
    close(hand);
    return ft.dw;
#endif
}
Beispiel #9
0
int YMODEMCLASS::WriteHeaderBlock (void)
{
	ftime     ft ;
	struct tm t ;
	char      drive[10] ;
	char      dir[50] ;
	char      name[256] ;
	char      ext[10] ;
  long      fileLength ;
	int i ;

	fltr_state = WAIT_ACK ;
	lpBuffer[0] = SOH ;
	lpBuffer[1] = 0 ;  
	lpBuffer[2] = 0xff ;
	for (i=3; i<133; i++) ;
		lpBuffer[i] = 0 ;
	if (fileCount>0)
		{
		fnsplit (filename, drive, dir, name, ext) ;
		strcat (name,ext) ;
		fileLength = SetFilePointer (hFile, 0, 2) ;
		SetFilePointer (hFile, 0, 0) ;

    getftime(hFile, &ft) ;
    t.tm_sec = ft.ft_tsec*2 ;   
    t.tm_min = ft.ft_min ;   
    t.tm_hour= ft.ft_hour ;  
		t.tm_mday= ft.ft_day ;
		t.tm_mon = ft.ft_month - 1 ;
    t.tm_year= ft.ft_year +80 ;  
		t.tm_isdst= FALSE ;

		putenv("TZ=GMT0GMT") ;
		tzset() ;
		sprintf (lpBuffer+3, "%s%c%ld %lo 0", filename, 0x00, fileLength, mktime(&t)) ;
		}
	else
  	lpBuffer[3] = '\0' ;

  nTransSize = 132 ;
	if (fCRC)
		{
		nTransSize = 133 ;
		int vCRC = CalcCRC16(&lpBuffer[DATA_OFFSET], 128) ;
		lpBuffer[CHK_OFFSET] = HIBYTE (vCRC) ;
		lpBuffer[CHK_OFFSET+1] =LOBYTE(vCRC) ;
		}
	else
		lpBuffer[CHK_OFFSET] = CheckSum (&lpBuffer[DATA_OFFSET]) ;

	CommPutBuffer (oiConn, (BYTE*)lpBuffer, nTransSize) ;

	if (Status)
		{
   	lstrcpy(lpStatus->filename, name) ;
		lpStatus->filesize = fileLength ;
		lpStatus->error = lErrorCount ;
		lpStatus->blocksize +=128 ; 
		lpStatus->UpdateStatusWindow () ;
		if (lpStatus->transferStop) return (FT_LOCALCANCEL) ;
   	}
	if (fileCount<=0)
		return (FT_FILEEND) ;
	else
		return (FT_SUCCESS) ;
}
Beispiel #10
0
//analyza PPP logu -> ziskani IP adresy
//!!JdS: 2003/12/7 {
//  Rewritten so that 'ppplogtime' can also be initialized when
//  using BOOTP via a dial-up connection. See also ArachneTCPIP().
//!!JdS: 2003/12/7 }
int PPPlog(void)
{
 int f,i,j;
 char *p;
 struct ftime ft;
 struct time d_time;
 struct date d_date;

 f=sopen("PPP.LOG",O_RDONLY|O_TEXT,SH_COMPAT, S_IREAD);
 if (f>=0)
 {
  if (ipmode==MODE_PPP)
  {
   long l=a_filelength(f);
   int plen;
   char buf[LOGLEN];

   if (l>LOGLEN)
    l=LOGLEN;
   lseek(f,-l,SEEK_END);
   i=read(f,buf,(int)l);
   buf[i]='\0';

   //puts(buf);
   j=0;
   p=configvariable(&ARACHNEcfg,"IP_Grab",NULL);
   if (!p)
    p="IP address set to";
   plen=strlen(p);
   while(j<i)
   {
    if (!strncmp(&buf[j],p,plen))
    {
     char tecka=0;

     p=strchr(&buf[j],'\n');
     if (p)
      *p='\0';

     outs(&buf[j]);
     i=0;
     j+=plen;
     while(buf[j]==' ')j++;
     while(i<19 &&
	   (buf[j+i]>='0' && buf[j+i]<='9' ||
	    buf[j+i]=='.' && tecka<3))
     {
      myIPstr[i]=buf[j+i];
      if (myIPstr[i]=='.')
       tecka++;
      i++;
     }
     myIPstr[i]='\0';
     my_ip_addr = resolve(myIPstr);
     break;
    }
    j++;
   }
  }

  //determine time online:
  if (my_ip_addr || ipmode==MODE_BOOTP)
  {
   getftime(f, &ft);
   d_date.da_year=ft.ft_year+1980;     /* current year */
   d_date.da_day=ft.ft_day;     /* day of the month */
   d_date.da_mon=ft.ft_month;     /* month (1 = Jan) */
   d_time.ti_min=ft.ft_min;   /* minutes */
   d_time.ti_hour=ft.ft_hour;  /* hours */
   d_time.ti_hund=0;  /* hundredths of seconds */
   d_time.ti_sec=ft.ft_tsec*2;   /* seconds */
   //ppplogtime is by default zero...
   ppplogtime = dostounix(&d_date, &d_time);
  }

  close(f);
  return(my_ip_addr || ipmode==MODE_BOOTP);
 }

 //puts(MSG_NOIP);
 return(0);
}
Beispiel #11
0
void do_one_file(const char *iname, char *oname)
{
    int r;
    struct stat st;
    memset(&st, 0, sizeof(st));
#if (HAVE_LSTAT)
    r = lstat(iname, &st);
#else
    r = stat(iname, &st);
#endif
    if (r != 0)
    {
        if (errno == ENOENT)
            throw FileNotFoundException(iname, errno);
        else
            throwIOException(iname, errno);
    }
    if (!(S_ISREG(st.st_mode)))
        throwIOException("not a regular file -- skipped");
#if defined(__unix__)
    // no special bits may be set
    if ((st.st_mode & (S_ISUID | S_ISGID | S_ISVTX)) != 0)
        throwIOException("file has special permissions -- skipped");
#endif
    if (st.st_size <= 0)
        throwIOException("empty file -- skipped");
    if (st.st_size < 512)
        throwIOException("file is too small -- skipped");
    if (!mem_size_valid_bytes(st.st_size))
        throwIOException("file is too large -- skipped");
    if ((st.st_mode & S_IWUSR) == 0)
    {
        bool skip = true;
        if (opt->output_name)
            skip = false;
        else if (opt->to_stdout)
            skip = false;
        else if (opt->backup)
            skip = false;
        if (skip)
            throwIOException("file is write protected -- skipped");
    }

    InputFile fi;
    fi.st = st;
    fi.sopen(iname, O_RDONLY | O_BINARY, SH_DENYWR);

#if (USE_FTIME)
    struct ftime fi_ftime;
    memset(&fi_ftime, 0, sizeof(fi_ftime));
    if (opt->preserve_timestamp)
    {
        if (getftime(fi.getFd(), &fi_ftime) != 0)
            throwIOException("cannot determine file timestamp");
    }
#endif

    // open output file
    OutputFile fo;
    if (opt->cmd == CMD_COMPRESS || opt->cmd == CMD_DECOMPRESS)
    {
        if (opt->to_stdout)
        {
            if (!fo.openStdout(1, opt->force ? true : false))
                throwIOException("data not written to a terminal; Use '-f' to force.");
        }
        else
        {
            char tname[ACC_FN_PATH_MAX+1];
            if (opt->output_name)
                strcpy(tname,opt->output_name);
            else
            {
                if (!maketempname(tname, sizeof(tname), iname, ".upx"))
                    throwIOException("could not create a temporary file name");
            }
            if (opt->force >= 2)
            {
#if (HAVE_CHMOD)
                r = chmod(tname, 0777);
                IGNORE_ERROR(r);
#endif
                r = unlink(tname);
                IGNORE_ERROR(r);
            }
            int flags = O_CREAT | O_WRONLY | O_BINARY;
            if (opt->force)
                flags |= O_TRUNC;
            else
                flags |= O_EXCL;
            int shmode = SH_DENYWR;
#if defined(__MINT__)
            flags |= O_TRUNC;
            shmode = O_DENYRW;
#endif
            // cannot rely on open() because of umask
            //int omode = st.st_mode | 0600;
            int omode = 0600;
            if (!opt->preserve_mode)
                omode = 0666;
            fo.sopen(tname,flags,shmode,omode);
            // open succeeded - now set oname[]
            strcpy(oname,tname);
        }
    }

    // handle command
    PackMaster pm(&fi, opt);
    if (opt->cmd == CMD_COMPRESS)
        pm.pack(&fo);
    else if (opt->cmd == CMD_DECOMPRESS)
        pm.unpack(&fo);
    else if (opt->cmd == CMD_TEST)
        pm.test();
    else if (opt->cmd == CMD_LIST)
        pm.list();
    else if (opt->cmd == CMD_FILEINFO)
        pm.fileInfo();
    else
        throwInternalError("invalid command");

    // copy time stamp
    if (opt->preserve_timestamp && oname[0] && fo.isOpen())
    {
#if (USE_FTIME)
        r = setftime(fo.getFd(), &fi_ftime);
        IGNORE_ERROR(r);
#elif (USE__FUTIME)
        struct _utimbuf u;
        u.actime = st.st_atime;
        u.modtime = st.st_mtime;
        r = _futime(fo.getFd(), &u);
        IGNORE_ERROR(r);
#endif
    }

    // close files
    fo.closex();
    fi.closex();

    // rename or delete files
    if (oname[0] && !opt->output_name)
    {
        // FIXME: .exe or .cof etc.
        if (!opt->backup)
        {
#if (HAVE_CHMOD)
            r = chmod(iname, 0777);
            IGNORE_ERROR(r);
#endif
            File::unlink(iname);
        }
        else
        {
            // make backup
            char bakname[ACC_FN_PATH_MAX+1];
            if (!makebakname(bakname, sizeof(bakname), iname))
                throwIOException("could not create a backup file name");
            File::rename(iname,bakname);
        }
        File::rename(oname,iname);
    }

    // copy file attributes
    if (oname[0])
    {
        oname[0] = 0;
        const char *name = opt->output_name ? opt->output_name : iname;
        UNUSED(name);
#if (USE_UTIME)
        // copy time stamp
        if (opt->preserve_timestamp)
        {
            struct utimbuf u;
            u.actime = st.st_atime;
            u.modtime = st.st_mtime;
            r = utime(name, &u);
            IGNORE_ERROR(r);
        }
#endif
#if (HAVE_CHMOD)
        // copy permissions
        if (opt->preserve_mode)
        {
            r = chmod(name, st.st_mode);
            IGNORE_ERROR(r);
        }
#endif
#if (HAVE_CHOWN)
        // copy the ownership
        if (opt->preserve_ownership)
        {
            r = chown(name, st.st_uid, st.st_gid);
            IGNORE_ERROR(r);
        }
#endif
    }

    UiPacker::uiConfirmUpdate();
}
Beispiel #12
0
	static int inner_copy(
	  const char *src,
	  const char *dst,
	  int replaceOk)
	{
	  int in = -1, out = -1;                  // file handles
	  int result = -1;                // default to error

	  int bufsize = 0;
	  void *buf = NULL;

	  for(bufsize=0x4000; buf == NULL && bufsize >= 128; bufsize /= 2)
		buf = malloc(bufsize);
	  if (buf==NULL) { /* no errors allowed here! */
		static char dummy[4];
		buf = dummy;
		bufsize = 4;
	  }


	  in = open(src,O_RDONLY|O_BINARY);
	  if (in >= 0) {
		out = open(dst, O_BINARY | O_CREAT | O_RDWR |
					(replaceOk ? O_TRUNC : O_EXCL),
					S_IREAD|S_IWRITE);
		if (out >= 0) {
		  int lastwrite, nbytes;
		  while ((nbytes = read(in, buf, bufsize)) > 0) {
			lastwrite = write(out, buf, nbytes);
			if (lastwrite==-1) break;
		  }
		  if (lastwrite>=0) {
#ifdef _WIN32
			struct _timeb ftime;
#else
			struct ftime ftime;
#endif
			getftime(in,&ftime);
			setftime(out,&ftime);
			result = 0;
		  } else mydir_errno = WRITE_ERROR;

		  close(out);
		  // put this here so if fail 'cause of existence,
		  // we don't remove the unreplaced file!
		  // also, the file must be closed to remove
		  if (result) remove(dst);
		} else {
		  mydir_errno = DST_OPEN_ERROR;
		  switch(errno) {
			case EEXIST: mydir_errno = DST_ALREADY_EXIST; break;
		  }
		}
		close(in);
	  } else {
		mydir_errno = SRC_OPEN_ERROR;
		switch(errno) {
		  case ENOENT: mydir_errno = SRC_NO_EXIST; break;
		}
	  }

	  assert(buf);
	  if (bufsize != 4) free(buf);

	  return result;
	}
Beispiel #13
0
int	scan(char *filename)
{
	struct	tifile *ff;

	int	handle;
	longint	fdrtotalbytes;
	longint	totalbytes;
	longint	databytes;
	struct	fdrstruc *fdr;
	char	name[14];
	word	oldsize;

	struct	ftime ftime;

	byte	type,len;

SAY	printf("Scanning file %s\n",filename);

	if (!openti(filename,&handle))
	{
		tierror(filename);
		return 0;
	}


	ff=&tifiles[handle];
	getftime(ff->doshandle,&ftime);

	//  Check FDR structure.

	fdr=&ff->fdr;
	type=fdr->flags;
	len=fdr->reclen;

	if (!validatename(fdr->name))
	{
		if (fix)
		{
		getname(fdr->name,name);
		memcpy(fdr->name,name+2,10);
		}
	}


	if (!(type&F_PROGRAM) && len==0)
	{
		printf("Invalid record length (0)\n");

		if (fix)
		{

		    if (fdr->recspersec==1)
			    len=255;	// good guess for xxx/FIX
		    else
		    if (fdr->recspersec>1)
			    len=256/fdr->recspersec; // very approx
		    else
			    len=80;		// pure guess

		    //  For fixed files, we can tell what the record size is:
		    //  *  EOF offset is exact multiple
		    //  *  (256*secsused-EOF)/fixrecs is almost it
		    if (!(type&F_VARIABLE) && fdr->fixrecs)
		    {
			len=(256L*(swapbytes(fdr->secsused)+1)-fdr->eof) /
			   fdr->fixrecs;
			if (fdr->eof)
				while (len%fdr->eof)
					len--;
		    }

		    if (!len)
			len=80;

		    printf("\tAssume %d bytes?\n",len);
		    if (getyesorno())
			    fdr->reclen=len;

		}

	}


	fdrtotalbytes=tigetfilesize(handle);
	totalbytes=tigetrealfilesize(handle);

	if ((fdrtotalbytes+255)/256!=totalbytes/256)
	{
		printf("File size mismatch in %s\n",filename);
		printf("TI Emulator! v5.0- probably made this error.\n");

		if (fix)
		{
		if ((type&F_VARIABLE) && !(type&F_PROGRAM))	// xxx/VAR
		{
			fdr->fixrecs=totalbytes/256;
			fdr->secsused=swapbytes(fdr->fixrecs);
		}
		else if (type&F_PROGRAM)			// program
		{
		//  On a program file, most likely the FDR is
		//  correct while the filesize is wrong.  Sheesh!
		//
		    if (fdrtotalbytes<totalbytes)
		    if (!ff->doad)
			trunc(handle,swapbytes(fdr->secsused));

		    else ;
		    else
		    {
			fdr->secsused=swapbytes(totalbytes/256);
			fdr->eof=totalbytes&255;
		    }
		}
		else if (!(type&F_VARIABLE))			// xxx/FIX
		{
		//	reclen is assumed to be legal from above
		//
			oldsize=fdr->secsused;
			fdr->secsused=swapbytes(
			    (fdr->fixrecs+fdr->recspersec-1)/fdr->recspersec);
			if (oldsize==fdr->secsused && !ff->doad)
				trunc(handle,swapbytes(oldsize));
		}
		}
	}

	if (fix)
	{
//		printf("Fixing...\n");
		if (!writetifdr(handle))
			printf("Error!  Couldn't write header!\n");
		else
			setftime(ff->doshandle,&ftime);
	}
	closeti(handle);

	return	1;
}