コード例 #1
0
ファイル: OptionsDialog.cpp プロジェクト: ArthurRTz/tibiaauto
/* ===========================================================================
 * Compress the given file: create a corresponding .gz file and remove the
 * original.
 */
void file_compress(char *file, char *mode)
{
	char outfile[MAX_NAME_LEN];
	FILE  *in;
	gzFile out;

	strcpy(outfile, file);
	strcat(outfile, ".gz");

	in = fopen(file, "rb");
	if (in == NULL)
	{
		char msgBuf[2048];
		sprintf(msgBuf, "ERROR: Unable to send file. %s  %s", strerror(errno), file);
		AfxMessageBox(msgBuf);
		return;
	}
	out = gzopen(outfile, mode);
	if (out == NULL)
	{
		AfxMessageBox("ERROR: unable to make gzip compression");
		return;
	}
	gz_compress(in, out);
}
コード例 #2
0
ファイル: minigzip.c プロジェクト: zeromus/biz-stella
/* ===========================================================================
 * Compress the given file: create a corresponding .gz file and remove the
 * original.
 */
void file_compress(
    char  *file,
    char  *mode)
{
    local char outfile[MAX_NAME_LEN];
    FILE  *in;
    gzFile out;

    if (strlen(file) + strlen(GZ_SUFFIX) >= sizeof(outfile)) {
        fprintf(stderr, "%s: filename too long\n", prog);
        exit(1);
    }

    strcpy(outfile, file);
    strcat(outfile, GZ_SUFFIX);

    in = fopen(file, "rb");
    if (in == NULL) {
        perror(file);
        exit(1);
    }
    out = gzopen(outfile, mode);
    if (out == NULL) {
        fprintf(stderr, "%s: can't gzopen %s\n", prog, outfile);
        exit(1);
    }
    gz_compress(in, out);

    unlink(file);
}
コード例 #3
0
ファイル: dlp_file.c プロジェクト: thias42/dLabPro
/**
 * Compress the given file: create a temporary output file. Remove original
 * file and rename temporary file after successfull completion of gz_compress().
 *
 * @param lpsInfile
 *       Pointer to filename of input file
 * @param lpsMode
 *       Mode of file compression. ("wb[0-9]")
 * @return <code>TRUE</code> if compression succeeded, <code>FALSE</code> otherwise.
 */
BOOL dlp_fzip(const char *lpsInfile, const char *lpsMode)
{
#ifndef __NOZLIB
  char   lpsFile[L_PATH];
  char   lpsDir[L_PATH];
  char  *lpsOutfile = NULL;
  BOOL   bSuccess = TRUE;
    FILE  *lpInfile;
    gzFile lpOutfile;

  /* Open input file */
    lpInfile = fopen(lpsInfile, "rb");
    if (lpInfile == NULL) {
        perror(lpsInfile);
        return FALSE;
    }

  /* Create and open temporary output file */
  dlp_splitpath(lpsInfile,lpsDir,lpsFile);
  lpsOutfile = dlp_tempnam(NULL,lpsFile);
    lpOutfile = gzopen(lpsOutfile, lpsMode);
    if (lpOutfile == NULL) {
        fprintf(stderr, "zlib@zlib_fcompress(): can't gzopen %s\n", lpsOutfile);
        fclose(lpInfile);
        return FALSE;
    }


    bSuccess = gz_compress(lpInfile, lpOutfile);

  if(bSuccess)
  {
      strncpy(lpsFile,lpsInfile,L_PATH-2);
      strcat(lpsFile,"~");
      rename(lpsInfile,lpsFile);
      if(gz_rename(lpsOutfile,lpsInfile)==0)
      {
    if(unlink(lpsFile))  perror("unlink");
      }
      else
      {
    fprintf(stderr, "zlib@zlib_fcompress(): failed to compress file. Save %s uncompressed\n", lpsInfile);
    unlink(lpsInfile);
    rename(lpsFile,lpsInfile);
      }
  }
  else
  {
      fprintf(stderr, "zlib@zlib_fcompress(): failed to compress file. Save %s uncompressed\n", lpsInfile);
      if(unlink(lpsOutfile)) perror("unlink");
  }

  return TRUE;
#else /* __NOZLIB */
  return FALSE;
#endif
}
コード例 #4
0
ファイル: utils.cpp プロジェクト: NBY/hCraft
		unsigned char*
		gz_compress (unsigned char *src, unsigned long slen, long& dest_size, int level)
		{
		#define GZIP_HEADER_SIZE 256
			unsigned char *dest = new unsigned char [compressBound (slen)
				+ GZIP_HEADER_SIZE];
			if ((dest_size = gz_compress (src, slen, dest, level)) < 0)
				{
					delete[] dest;
					return nullptr;
				}	
			return dest;
		}
コード例 #5
0
static void
handle_stdout(void)
{
	off_t gsize, usize;
	struct stat sb;
	time_t systime;
	uint32_t mtime;
	int ret;

#ifndef SMALL
	if (fflag == 0 && isatty(STDOUT_FILENO)) {
		maybe_warnx("standard output is a terminal -- ignoring");
		return;
	}
#endif
	/* If stdin is a file use its mtime, otherwise use current time */
	ret = fstat(STDIN_FILENO, &sb);

#ifndef SMALL
	if (ret < 0) {
		maybe_warn("Can't stat stdin");
		return;
	}
#endif

	if (S_ISREG(sb.st_mode))
		mtime = (uint32_t)sb.st_mtime;
	else {
		systime = time(NULL);
#ifndef SMALL
		if (systime == -1) {
			maybe_warn("time");
			return;
		} 
#endif
		mtime = (uint32_t)systime;
	}
	 		
	usize = gz_compress(STDIN_FILENO, STDOUT_FILENO, &gsize, "", mtime);
#ifndef SMALL
        if (vflag && !tflag && usize != -1 && gsize != -1)
		print_verbage(NULL, NULL, usize, gsize);
#endif 
}
コード例 #6
0
ファイル: Join.cpp プロジェクト: xsgluozi/VisionLibrary
/* ===========================================================================
 * Compress the given file: create a corresponding .gz file and remove the
 * original. @2
 */
short file_compress(const char *szDir, const char *szFileName,
    const char *szSrcExt, const char *szZipExt, const char *mode)
{
    char
        szSourceFile[MAX_NAME_LEN],
        szGzipFile[MAX_NAME_LEN];
    FILE  *in;
    gzFile out;

    if (strlen(szDir))
        strcpy (szSourceFile, szDir);
    else
        strcpy (szSourceFile, ".");
    strcat (szSourceFile, "\\");
    strcat (szSourceFile, szFileName);
    strcpy (szGzipFile,   szSourceFile);
    strcat (szSourceFile, szSrcExt);
    strcat (szGzipFile,   szZipExt);

    in = fopen(szSourceFile, "rb");
    if (in == NULL) {
        perror(szSourceFile);
        return 1;
    }
    out = gzopen(szGzipFile, mode);
    if (out == NULL) {
        fclose(in);	//@4
        String msg = String ( "can't gzopen " ) + szGzipFile;
        throw std::exception( msg.c_str() );
        return 1;
    }
    gz_compress(in, out);

    _unlink(szSourceFile);
    fclose(in);	//@4
    return 0;
}
コード例 #7
0
/*
 * compress the given file: create a corresponding .gz file and remove the
 * original.
 */
static off_t
file_compress(char *file, char *outfile, size_t outsize)
{
	int in;
	int out;
	off_t size, insize;
#ifndef SMALL
	struct stat isb, osb;
	const suffixes_t *suff;
#endif

	in = open(file, O_RDONLY);
	if (in == -1) {
		maybe_warn("can't open %s", file);
		return -1;
	}

	if (cflag == 0) {
#ifndef SMALL
		if (fstat(in, &isb) == 0) {
			if (isb.st_nlink > 1 && fflag == 0) {
				maybe_warnx("%s has %d other link%s -- "
					    "skipping", file, isb.st_nlink - 1,
					    isb.st_nlink == 1 ? "" : "s");
				close(in);
				return -1;
			}
		}

		if (fflag == 0 && (suff = check_suffix(file, 0))
		    && suff->zipped[0] != 0) {
			maybe_warnx("%s already has %s suffix -- unchanged",
				    file, suff->zipped);
			close(in);
			return -1;
		}
#endif

		/* Add (usually) .gz to filename */
		if ((size_t)snprintf(outfile, outsize, "%s%s",
					file, suffixes[0].zipped) >= outsize)
			memcpy(outfile + outsize - suffixes[0].ziplen - 1,
				suffixes[0].zipped, suffixes[0].ziplen + 1);

#ifndef SMALL
		if (check_outfile(outfile) == 0) {
			close(in);
			return -1;
		}
#endif
	}

	if (cflag == 0) {
		out = open(outfile, O_WRONLY | O_CREAT | O_EXCL, 0600);
		if (out == -1) {
			maybe_warn("could not create output: %s", outfile);
			fclose(stdin);
			return -1;
		}
	} else
		out = STDOUT_FILENO;

	insize = gz_compress(in, out, &size, basename(file), (uint32_t)isb.st_mtime);

	(void)close(in);

	/*
	 * If there was an error, insize will be -1.
	 * If we compressed to stdout, just return the size.
	 * Otherwise stat the file and check it is the correct size.
	 * We only blow away the file if we can stat the output and it
	 * has the expected size.
	 */
	if (cflag != 0)
		return insize == -1 ? -1 : size;

#ifndef SMALL
	if (fstat(out, &osb) != 0) {
		maybe_warn("couldn't stat: %s", outfile);
		goto bad_outfile;
	}

	if (osb.st_size != size) {
		maybe_warnx("output file: %s wrong size (%" PRIdOFF
				" != %" PRIdOFF "), deleting",
				outfile, osb.st_size, size);
		goto bad_outfile;
	}

	copymodes(out, &isb, outfile);
#endif
	if (close(out) == -1)
		maybe_warn("couldn't close output");

	/* output is good, ok to delete input */
	unlink_input(file, &isb);
	return size;

#ifndef SMALL
    bad_outfile:
	if (close(out) == -1)
		maybe_warn("couldn't close output");

	maybe_warnx("leaving original %s", file);
	unlink(outfile);
	return size;
#endif
}
コード例 #8
0
ファイル: consistency.c プロジェクト: CTSRD-SOAAP/soaap
int main() {
  __soaap_create_persistent_sandbox("compress");
  some_flag = 1;
  gz_compress(0, 1);
  return 0;
}
コード例 #9
0
ファイル: minigzip.c プロジェクト: zeromus/biz-stella
int main(
    int argc,
    char *argv[])
{
    int copyout = 0;
    int uncompr = 0;
    gzFile file;
    char *bname, outmode[20];

    strcpy(outmode, "wb6 ");

    prog = argv[0];
    bname = strrchr(argv[0], '/');
    if (bname)
      bname++;
    else
      bname = argv[0];
    argc--, argv++;

    if (!strcmp(bname, "gunzip"))
      uncompr = 1;
    else if (!strcmp(bname, "zcat"))
      copyout = uncompr = 1;

    while (argc > 0) {
      if (strcmp(*argv, "-c") == 0)
        copyout = 1;
      else if (strcmp(*argv, "-d") == 0)
        uncompr = 1;
      else if (strcmp(*argv, "-f") == 0)
        outmode[3] = 'f';
      else if (strcmp(*argv, "-h") == 0)
        outmode[3] = 'h';
      else if (strcmp(*argv, "-r") == 0)
        outmode[3] = 'R';
      else if ((*argv)[0] == '-' && (*argv)[1] >= '1' && (*argv)[1] <= '9' &&
               (*argv)[2] == 0)
        outmode[2] = (*argv)[1];
      else
        break;
      argc--, argv++;
    }
    if (outmode[3] == ' ')
        outmode[3] = 0;
    if (argc == 0) {
        SET_BINARY_MODE(stdin);
        SET_BINARY_MODE(stdout);
        if (uncompr) {
            file = gzdopen(fileno(stdin), "rb");
            if (file == NULL) error("can't gzdopen stdin");
            gz_uncompress(file, stdout);
        } else {
            file = gzdopen(fileno(stdout), outmode);
            if (file == NULL) error("can't gzdopen stdout");
            gz_compress(stdin, file);
        }
    } else {
        if (copyout) {
            SET_BINARY_MODE(stdout);
        }
        do {
            if (uncompr) {
                if (copyout) {
                    file = gzopen(*argv, "rb");
                    if (file == NULL)
                        fprintf(stderr, "%s: can't gzopen %s\n", prog, *argv);
                    else
                        gz_uncompress(file, stdout);
                } else {
                    file_uncompress(*argv);
                }
            } else {
                if (copyout) {
                    FILE * in = fopen(*argv, "rb");

                    if (in == NULL) {
                        perror(*argv);
                    } else {
                        file = gzdopen(fileno(stdout), outmode);
                        if (file == NULL) error("can't gzdopen stdout");

                        gz_compress(in, file);
                    }

                } else {
                    file_compress(*argv, outmode);
                }
            }
        } while (argv++, --argc);
    }
    return 0;
}